用C语言对于给定的循环链表,编写算法要求删除链表中所有重复的元素

可以使用双重循环遍历链表，对于每个节点，再遍历一遍链表，删除所有与该节点值相同的节点。具体实现可以参考以下代码：

typedef struct Node {
    int val;
    struct Node* next;
} Node;

void deleteDuplicates(Node* head) {
    Node* cur = head;
    while (cur != NULL) {
        Node* prev = cur;
        Node* p = cur->next;
        while (p != NULL) {
            if (p->val == cur->val) {
                prev->next = p->next;
                free(p);
                p = prev->next;
            } else {
                prev = p;
                p = p->next;
            }
        }
        cur = cur->next;
    }
}

其中，cur指向当前节点，prev指向cur的前一个节点，p指向cur的下一个节点。在内层循环中，如果p的值与cur相同，则删除p节点；否则，将prev和p都向后移动一个节点。最后，将cur指向下一个节点，继续循环。

相关问题

用c语言实现给定两个链表，每个链表都已经按升序排列，设计算法实现将两个链表合并到一个升序链表中，返回合并后的链表。

#include <stdio.h>
#include <stdlib.h>

/* 链表结构体 */
typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

/* 创建链表 */
ListNode* createList(int* nums, int numsSize) {
    ListNode* head = NULL;
    ListNode* tail = NULL;
    for (int i = 0; i < numsSize; i++) {
        ListNode* node = (ListNode*)malloc(sizeof(ListNode));
        node->val = nums[i];
        node->next = NULL;
        if (head == NULL) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = tail->next;
        }
    }
    return head;
}

/* 合并两个链表 */
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode* head = NULL;
    ListNode* tail = NULL;
    while (l1 != NULL && l2 != NULL) {
        ListNode* node = (ListNode*)malloc(sizeof(ListNode));
        if (l1->val < l2->val) {
            node->val = l1->val;
            l1 = l1->next;
        } else {
            node->val = l2->val;
            l2 = l2->next;
        }
        node->next = NULL;
        if (head == NULL) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = tail->next;
        }
    }
    if (l1 != NULL) {
        if (head == NULL) {
            head = l1;
        } else {
            tail->next = l1;
        }
    }
    if (l2 != NULL) {
        if (head == NULL) {
            head = l2;
        } else {
            tail->next = l2;
        }
    }
    return head;
}

/* 输出链表 */
void printList(ListNode* head) {
    while (head != NULL) {
        printf("%d ", head->val);
        head = head->next;
    }
    printf("\n");
}

int main() {
    int nums1[] = {1, 2, 4};
    int nums2[] = {1, 3, 4};
    ListNode* l1 = createList(nums1, 3);
    ListNode* l2 = createList(nums2, 3);
    ListNode* merged = mergeTwoLists(l1, l2);
    printList(merged);
    return 0;
}

设二叉树为以二叉链表为存储结构，且树中结点的关键字均不同。用c语言编写算法，判别给定二叉树是否为二叉排序树

可以使用中序遍历二叉树，将遍历结果存储在一个数组中，然后判断数组是否为升序排列即可。

具体实现代码如下：

#include <stdio.h>
#include <stdlib.h>

// 二叉树结点定义
typedef struct node {
    int data; // 结点数据
    struct node *left; // 左子树指针
    struct node *right; // 右子树指针
} Node;

// 中序遍历二叉树，将结果存储在数组中
void inorder(Node *root, int arr[], int *index) {
    if (root == NULL) {
        return;
    }
    inorder(root->left, arr, index);
    arr[(*index)++] = root->data;
    inorder(root->right, arr, index);
}

// 判断数组是否为升序排列
int isSorted(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] > arr[i+1]) {
            return 0;
        }
    }
    return 1;
}

// 判断给定二叉树是否为二叉排序树
int isBST(Node *root) {
    int arr[100]; // 存储中序遍历结果的数组
    int index = 0; // 数组下标
    inorder(root, arr, &index);
    return isSorted(arr, index);
}

// 创建二叉树结点
Node* createNode(int data) {
    Node *node = (Node*) malloc(sizeof(Node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    // 创建二叉排序树
    Node *root = createNode(4);
    root->left = createNode(2);
    root->left->left = createNode(1);
    root->left->right = createNode(3);
    root->right = createNode(6);
    root->right->left = createNode(5);
    root->right->right = createNode(7);

    // 判断是否为二叉排序树
    if (isBST(root)) {
        printf("给定二叉树是二叉排序树\n");
    } else {
        printf("给定二叉树不是二叉排序树\n");
    }

    return 0;
}

输出结果：

给定二叉树是二叉排序树