用C语言写出两个链表按大小顺序合并的子函数部分

下面是一个示例代码，其中假设链表节点的结构体定义为`Node`，其中包含一个整数`value`和指向下一个节点的指针`next`：

Node* merge_sorted_lists(Node* list1, Node* list2) {
    if (list1 == NULL) {
        return list2;
    }
    else if (list2 == NULL) {
        return list1;
    }
    else if (list1->value <= list2->value) {
        list1->next = merge_sorted_lists(list1->next, list2);
        return list1;
    }
    else {
        list2->next = merge_sorted_lists(list1, list2->next);
        return list2;
    }
}

这个函数会递归地比较两个链表的节点大小，将它们按照升序排列合并成一个链表并返回。如果其中一个链表为空，则直接返回另一个链表。

相关问题

用C语言写出两个链表按大小顺序合并

下面是用C语言实现的两个链表按大小顺序合并的示例代码：

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

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

// 创建新的链表节点
struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

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

int main() {
    // 创建两个有序链表
    struct ListNode* l1 = createNode(1);
    l1->next = createNode(3);
    l1->next->next = createNode(5);
    struct ListNode* l2 = createNode(2);
    l2->next = createNode(4);
    l2->next->next = createNode(6);
    l2->next->next->next = createNode(8);

    // 合并两个有序链表
    struct ListNode* mergedList = mergeTwoLists(l1, l2);

    // 输出合并后的链表
    while (mergedList) {
        printf("%d ", mergedList->val);
        mergedList = mergedList->next;
    }
    printf("\n");

    return 0;
}

输出结果为：1 2 3 4 5 6 8

用C语言实现两个链表按大小顺序合并

下面是一个示例代码，假设链表节点的结构体为Node，有两个链表head1和head2，将它们合并并按大小顺序排列：

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

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

Node* merge(Node *head1, Node *head2) {
    Node *newHead = NULL;  // 合并后的新链表头节点
    Node *tail = NULL;  // 新链表的尾节点
    Node *p1 = head1;
    Node *p2 = head2;

    // 遍历两个链表，比较节点大小并将较小的节点插入到新链表中
    while (p1 != NULL && p2 != NULL) {
        Node *temp = NULL;
        if (p1->data < p2->data) {
            temp = p1;
            p1 = p1->next;
        } else {
            temp = p2;
            p2 = p2->next;
        }
        if (newHead == NULL) {
            newHead = temp;
            tail = temp;
        } else {
            tail->next = temp;
            tail = temp;
        }
    }

    // 将剩余的节点直接插入到新链表的尾部
    if (p1 != NULL) {
        tail->next = p1;
    } else {
        tail->next = p2;
    }

    return newHead;
}

int main() {
    Node *head1 = NULL;
    Node *head2 = NULL;

    // 构造两个有序链表
    for (int i = 1; i <= 5; i++) {
        Node *node = (Node*)malloc(sizeof(Node));
        node->data = i;
        node->next = NULL;
        if (head1 == NULL) {
            head1 = node;
        } else {
            Node *p = head1;
            while (p->next != NULL) {
                p = p->next;
            }
            p->next = node;
        }
    }

    for (int i = 3; i <= 8; i++) {
        Node *node = (Node*)malloc(sizeof(Node));
        node->data = i;
        node->next = NULL;
        if (head2 == NULL) {
            head2 = node;
        } else {
            Node *p = head2;
            while (p->next != NULL) {
                p = p->next;
            }
            p->next = node;
        }
    }

    // 输出原链表
    printf("head1: ");
    Node *p = head1;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

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

    // 合并链表并输出结果
    Node *newHead = merge(head1, head2);
    printf("merged: ");
    p = newHead;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    // 释放链表节点的内存
    p = head1;
    while (p != NULL) {
        Node *temp = p;
        p = p->next;
        free(temp);
    }

    p = head2;
    while (p != NULL) {
        Node *temp = p;
        p = p->next;
        free(temp);
    }

    p = newHead;
    while (p != NULL) {
        Node *temp = p;
        p = p->next;
        free(temp);
    }

    return 0;
}

输出结果如下：

head1: 1 2 3 4 5 
head2: 3 4 5 6 7 8 
merged: 1 2 3 3 4 4 5 5 6 7 8