两个有序单链表的合并排序算法。c语言版

两个有序单链表进行合并排序。

算法思想:

       首先判断两个链表是否为空，如果其中一个链表为空，则直接返回另一个链表。如果两个链表都不为空，则创建一个新的链表用于保存合并结果，并设置一个尾部指针来方便链表节点的链接。然后通过比较两个链表的头节点值，确定合并后的链表的头节点，并将对应链表的指针向后移动。之后，我们依次比较链表中的节点值并进行链接操作，直到其中一个链表遍历完毕。最后，我们将剩下的节点链接到合并后的链表中，并返回合并后的链表头节点。
#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
typedef struct Node {
    int data;           // 节点数据
    struct Node* next;  // 指向下一个节点的指针
} Node;

// 创建新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("Memory allocation failed.\n");
        return NULL;
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 向链表末尾添加节点
void append(Node** headRef, int data) {
    Node* newNode = createNode(data);
    if (*headRef == NULL) {
        *headRef = newNode;
    } else {
        Node* temp = *headRef;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}

// 打印链表元素
void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

// 合并排序两个有序单链表
Node* mergeSort(Node* list1, Node* list2) {
    // 创建一个虚拟头节点，用于方便处理
    Node dummy;
    Node* tail = &dummy;
    dummy.next = NULL;

    // 依次比较两个链表的节点值，将较小的节点链接到合并链表中
    while (list1 != NULL && list2 != NULL) {
        if (list1->data <= list2->data) {
            tail->next = list1;
            list1 = list1->next;
        } else {
            tail->next = list2;
            list2 = list2->next;
        }
        tail = tail->next;
    }

    // 将剩下的节点链接到合并链表中
    if (list1 != NULL) {
        tail->next = list1;
    } else {
        tail->next = list2;
    }

    return dummy.next;  // 返回合并后的链表头节点
}

int main() {
    // 创建两个有序链表
    Node* list1 = NULL;
    append(&list1, 1);
    append(&list1, 3);
    append(&list1, 5);
    
    Node* list2 = NULL;
    append(&list2, 2);
    append(&list2, 4);
    append(&list2, 6);
    
    printf("List 1: ");
    printList(list1);
    
    printf("List 2: ");
    printList(list2);
    
    // 合并排序两个链表
    Node* mergedList = mergeSort(list1, list2);
    
    printf("Merged and sorted list: ");
    printList(mergedList);
    
    return 0;
}

✰✰✰将两个有序单链表A和B合并为一个有序单链表D（适用于期末，考研考试）

算法思想: 

       首先判断两个链表是否为空，如果其中一个链表为空，则直接返回另一个链表。如果两个链表都不为空，则创建一个新的链表D用于保存合并结果，并设置一个头部指针（headD）和尾部指针（tailD）。然后通过比较两个链表的头节点值，确定合并后的链表D的头节点，并将对应链表的指针向后移动。之后，我们依次比较链表中的节点值并进行链接操作，直到其中一个链表遍历完毕。最后，我们将剩下的节点链接到合并后的链表D中，并返回链表D的头节点。

Node* mergeSortedLists(Node* listA, Node* listB) {
    if (listA == NULL) {
        return listB;
    }
    
    if (listB == NULL) {
        return listA;
    }
    //上述判断A B 链表是否为空
    Node* headD = NULL;    //定义头指针
    Node* tailD = NULL;       //定义尾指针
    
    if (listA->data <= listB->data) {
        headD = listA;
        tailD = listA;
        listA = listA->next;
    } else {
        headD = listB;
        tailD = listB;
        listB = listB->next;
    }
    
    while (listA != NULL && listB != NULL) {
        if (listA->data <= listB->data) {
            tailD->next = listA;
            tailD = listA;
            listA = listA->next;
        } else {
            tailD->next = listB;
            tailD = listB;
            listB = listB->next;
        }
    }
    
    if (listA != NULL) {
        tailD->next = listA;
    } else {
        tailD->next = listB;
    }
    
    return headD;
}