把单链表A中的元素复制到单链表B中，用c语言

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

//复制单链表A到单链表B
ListNode* copyList(ListNode* head) {
if (head == NULL) {
return NULL;
}
ListNode *newHead = (ListNode*)malloc(sizeof(ListNode)); //新链表头结点
ListNode *p = head, *q = newHead; //p指向原链表当前节点，q指向新链表当前节点
while (p != NULL) {
q->next = (ListNode*)malloc(sizeof(ListNode)); //创建新节点
q = q->next; //移动新链表当前节点指针
q->val = p->val; //复制节点值
q->next = NULL; //新节点next指针置为空
p = p->next; //移动原链表当前节点指针
}
return newHead->next; //返回新链表头结点的next指针
}

相关问题

C语言中怎样用单链表删除重复元素

下面是一个用单链表删除重复元素的C语言代码：

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

typedef struct node {
    int data;
    struct node *next;
} Node, *LinkedList;

LinkedList createList(int n);  // 创建单链表
void printList(LinkedList list);  // 输出单链表
void deleteDuplicates(LinkedList list);  // 删除重复元素

int main()
{
    int n;
    LinkedList list;

    printf("请输入单链表的元素个数：");
    scanf("%d", &n);

    list = createList(n);
    printf("原始单链表：");
    printList(list);

    deleteDuplicates(list);
    printf("删除重复元素后的单链表：");
    printList(list);

    return 0;
}

LinkedList createList(int n)
{
    int i, data;
    Node *head, *p, *q;

    head = (Node *)malloc(sizeof(Node));
    head->next = NULL;
    q = head;

    for (i = 0; i < n; i++) {
        printf("请输入第%d个元素：", i + 1);
        scanf("%d", &data);
        p = (Node *)malloc(sizeof(Node));
        p->data = data;
        p->next = NULL;
        q->next = p;
        q = p;
    }

    return head->next;
}

void printList(LinkedList list)
{
    Node *p = list;

    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

void deleteDuplicates(LinkedList list)
{
    Node *p = list, *q, *r;

    while (p != NULL) {
        q = p;
        while (q->next != NULL) {
            if (q->next->data == p->data) {
                r = q->next;
                q->next = r->next;
                free(r);
            } else {
                q = q->next;
            }
        }
        p = p->next;
    }
}

这个代码中，我们首先定义了一个`Node`结构体，表示单链表的节点，其中包括数据成员`data`和指向下一个节点的指针`next`。然后，我们定义了一个`LinkedList`类型，表示单链表。`createList`函数用来创建单链表，它接收一个参数`n`，表示单链表的元素个数。在函数内部，我们先创建一个头节点`head`，然后通过循环读入用户输入的元素，并创建一个节点`p`，把它插入到链表的尾部。最后，返回头节点的下一个节点，即为创建好的单链表。

`printList`函数用来输出单链表的所有元素，它接收一个参数`list`，表示要输出的单链表。在函数内部，我们通过循环遍历单链表的每个节点，依次输出它的数据成员`data`。

`deleteDuplicates`函数用来删除单链表的重复元素，它接收一个参数`list`，表示要处理的单链表。在函数内部，我们通过两重循环遍历单链表的每个节点，如果发现有重复的元素，则删除后面的那个节点。具体来说，我们用指针`p`遍历单链表的每个节点，用指针`q`遍历从`p`开始的后面的节点。如果发现`q`指向的节点的数据成员`data`与`p`指向的节点相同，则删除`q`指向的节点，否则，继续往后遍历。这样，当所有的`q`节点都遍历完后，我们再把`p`指向下一个节点，继续遍历。最终，所有的重复元素都被删除了。

用C语言删除单链表中最小的元素

以下是用C语言删除单链表中最小的元素的示例代码：

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

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

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

// 删除最小元素
struct ListNode* deleteMin(struct ListNode* head) {
    if (head == NULL) {
        return NULL;
    }
    struct ListNode *prev = NULL, *minPrev = NULL, *minNode = head;
    while (head != NULL) {
        if (head->val < minNode->val) {
            minPrev = prev;
            minNode = head;
        }
        prev = head;
        head = head->next;
    }
    if (minPrev == NULL) {
        head = minNode->next;
    } else {
        minPrev->next = minNode->next;
    }
    free(minNode);
    return head;
}

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

int main() {
    int arr[] = {4, 2, 8, 1, 5};
    int size = sizeof(arr) / sizeof(int);
    struct ListNode *head = createList(arr, size);
    printf("原链表：");
    printList(head);
    head = deleteMin(head);
    printf("删除最小元素后：");
    printList(head);
    return 0;
}

运行结果：

原链表：4 2 8 1 5 
删除最小元素后：4 2 8 5