1. PingCode智库首页
  2. 百科

c语言如何对链表中的数据进行排序

Edit1 • • 百科

c语言如何对链表中的数据进行排序

C语言如何对链表中的数据进行排序：链表是一种常见的数据结构，用于动态存储数据。在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) {


        printf("Memory allocation errorn");


        return NULL;


    }


    newNode->data = data;


    newNode->next = NULL;


    return newNode;


}

插入节点

链表插入操作可以在头部、尾部或任意位置插入节点。以下是头部插入节点的函数：

// 头部插入节点


void insertAtHead(Node head, int data) {


    Node* newNode = createNode(data);


    newNode->next = *head;


    *head = newNode;


}

遍历链表

遍历链表是查看链表中所有节点数据的过程。以下是遍历链表的函数：

// 遍历链表


void printList(Node* head) {


    Node* current = head;


    while (current != NULL) {


        printf("%d -> ", current->data);


        current = current->next;


    }


    printf("NULLn");


}

二、链表排序算法

链表排序算法有多种选择，常见的包括插入排序、冒泡排序、归并排序和快速排序。接下来，我们逐一介绍这些算法，并详细讨论归并排序。

插入排序

插入排序是一种简单的排序算法，适用于小规模数据的排序。以下是链表插入排序的实现：

// 插入排序


Node* insertionSort(Node* head) {


    if (!head || !head->next) return head;


    Node* sorted = NULL;


    Node* current = head;


    while (current != NULL) {


        Node* next = current->next;


        sortedInsert(&sorted, current);


        current = next;


    }


    return sorted;


}


// 插入节点到排序链表


void sortedInsert(Node head, Node* newNode) {


    if (*head == NULL || (*head)->data >= newNode->data) {


        newNode->next = *head;


        *head = newNode;


    } else {


        Node* current = *head;


        while (current->next != NULL && current->next->data < newNode->data) {


            current = current->next;


        }


        newNode->next = current->next;


        current->next = newNode;


    }


}

冒泡排序

冒泡排序通过重复交换相邻节点的数据来排序。以下是链表冒泡排序的实现：

// 冒泡排序


void bubbleSort(Node* head) {


    if (!head) return;


    int swapped;


    Node* ptr1;


    Node* lptr = NULL;


    do {


        swapped = 0;


        ptr1 = head;


        while (ptr1->next != lptr) {


            if (ptr1->data > ptr1->next->data) {


                int temp = ptr1->data;


                ptr1->data = ptr1->next->data;


                ptr1->next->data = temp;


                swapped = 1;


            }


            ptr1 = ptr1->next;


        }


        lptr = ptr1;


    } while (swapped);


}

归并排序

归并排序是链表排序中最常用的算法之一。它利用了链表的特点，可以避免大量的数据移动，效率较高。以下是链表归并排序的实现：

归并排序的实现步骤

  1. 拆分链表：将链表拆分成两个子链表，递归地对每个子链表进行排序。
  2. 合并链表：将两个有序子链表合并成一个有序链表。

拆分链表

拆分链表使用快慢指针法，将链表分成两个子链表：

// 拆分链表


void splitList(Node* source, Node frontRef, Node backRef) {


    Node* fast;


    Node* slow;


    slow = source;


    fast = source->next;


    // 快慢指针法找到中点


    while (fast != NULL) {


        fast = fast->next;


        if (fast != NULL) {


            slow = slow->next;


            fast = fast->next;


        }


    }


    *frontRef = source;


    *backRef = slow->next;


    slow->next = NULL;


}

合并链表

合并两个有序链表：

// 合并两个有序链表


Node* sortedMerge(Node* a, Node* b) {


    Node* result = NULL;


    // 基本情况


    if (a == NULL) return b;


    if (b == NULL) return a;


    // 递归合并


    if (a->data <= b->data) {


        result = a;


        result->next = sortedMerge(a->next, b);


    } else {


        result = b;


        result->next = sortedMerge(a, b->next);


    }


    return result;


}

归并排序主函数

归并排序的主函数：

// 归并排序


void mergeSort(Node headRef) {


    Node* head = *headRef;


    Node* a;


    Node* b;


    // 基本情况


    if ((head == NULL) || (head->next == NULL)) return;


    // 拆分链表


    splitList(head, &a, &b);


    // 递归排序两个子链表


    mergeSort(&a);


    mergeSort(&b);


    // 合并两个有序链表


    *headRef = sortedMerge(a, b);


}

快速排序

快速排序是一种高效的排序算法，通常用于数组，但也可以应用于链表。以下是链表快速排序的实现：

快速排序的实现步骤

  1. 选择枢轴：选择一个节点作为枢轴。
  2. 分区：将链表分为两个子链表，一个子链表的节点值小于枢轴，另一个子链表的节点值大于枢轴。
  3. 递归排序：对两个子链表递归进行快速排序。

分区函数

分区函数将链表分为两个子链表：

// 分区函数


Node* partition(Node* head, Node* end, Node newHead, Node newEnd) {


    Node* pivot = end;


    Node* prev = NULL;


    Node* cur = head;


    Node* tail = pivot;


    while (cur != pivot) {


        if (cur->data < pivot->data) {


            if (*newHead == NULL) *newHead = cur;


            prev = cur;


            cur = cur->next;


        } else {


            if (prev) prev->next = cur->next;


            Node* temp = cur->next;


            cur->next = NULL;


            tail->next = cur;


            tail = cur;


            cur = temp;


        }


    }


    if (*newHead == NULL) *newHead = pivot;


    *newEnd = tail;


    return pivot;


}

快速排序主函数

快速排序的主函数：

// 快速排序


Node* quickSortRecur(Node* head, Node* end) {


    if (!head || head == end) return head;


    Node* newHead = NULL;


    Node* newEnd = NULL;


    Node* pivot = partition(head, end, &newHead, &newEnd);


    if (newHead != pivot) {


        Node* temp = newHead;


        while (temp->next != pivot) temp = temp->next;


        temp->next = NULL;


        newHead = quickSortRecur(newHead, temp);


        temp = getTail(newHead);


        temp->next = pivot;


    }


    pivot->next = quickSortRecur(pivot->next, newEnd);


    return newHead;


}


// 获取链表尾节点


Node* getTail(Node* head) {


    while (head != NULL && head->next != NULL) head = head->next;


    return head;


}


// 快速排序接口函数


void quickSort(Node headRef) {


    (*headRef) = quickSortRecur(*headRef, getTail(*headRef));


}

三、总结

链表排序在数据处理和算法设计中具有重要地位。插入排序、冒泡排序、归并排序和快速排序都是常用的链表排序算法。归并排序由于其高效性和稳定性，在链表排序中尤其常用。在实际应用中，可以根据具体需求选择合适的排序算法，以提高程序的效率和性能。

四、项目管理系统的应用

在处理复杂数据结构和算法时，良好的项目管理系统能够帮助团队更好地协作和管理项目。推荐使用研发项目管理系统PingCode和通用项目管理软件Worktile，它们能够提供强大的项目管理和任务跟踪功能，帮助团队高效地完成项目。

PingCode专注于研发项目管理，提供了丰富的功能，包括需求管理、任务分配、进度跟踪等，非常适合软件开发团队。

Worktile是一款通用项目管理软件，适用于各种类型的项目管理，提供了任务管理、团队协作、文件共享等功能，帮助团队提高工作效率。

通过合理选择和应用项目管理系统，团队可以更好地规划和执行项目，确保高质量的交付。

相关问答FAQs：

1. 如何使用C语言对链表中的数据进行排序？

C语言中，可以使用不同的排序算法对链表中的数据进行排序。常用的排序算法有冒泡排序、插入排序、选择排序、快速排序等。以下是一个示例使用快速排序算法对链表进行排序的代码片段：

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

// 链表节点结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 快速排序算法
Node* quickSort(Node* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    Node* pivot = head;
    Node* current = head->next;
    Node* smallerHead = NULL;
    Node* smallerTail = NULL;
    Node* greaterHead = NULL;
    Node* greaterTail = NULL;
    while (current != NULL) {
        if (current->data < pivot->data) {
            if (smallerHead == NULL) {
                smallerHead = current;
                smallerTail = current;
            } else {
                smallerTail->next = current;
                smallerTail = current;
            }
        } else {
            if (greaterHead == NULL) {
                greaterHead = current;
                greaterTail = current;
            } else {
                greaterTail->next = current;
                greaterTail = current;
            }
        }
        current = current->next;
    }
    if (smallerTail != NULL) {
        smallerTail->next = NULL;
        smallerHead = quickSort(smallerHead);
        Node* temp = smallerHead;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = pivot;
    } else {
        smallerHead = pivot;
    }
    if (greaterTail != NULL) {
        greaterTail->next = NULL;
        pivot->next = quickSort(greaterHead);
    } else {
        pivot->next = NULL;
    }
    return smallerHead;
}

// 测试代码
int main() {
    Node* head = NULL;
    Node* current = NULL;
    int data[] = {8, 3, 1, 5, 2};
    for (int i = 0; i < sizeof(data) / sizeof(data[0]); i++) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = data[i];
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            current = newNode;
        } else {
            current->next = newNode;
            current = newNode;
        }
    }
    printf("排序前的链表：");
    current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("n");
    head = quickSort(head);
    printf("排序后的链表：");
    current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("n");
    return 0;
}

2. 如何判断链表中的数据是否已经排序好了？

要判断链表中的数据是否已经排序好了，可以遍历链表，逐个比较节点的值。如果发现存在前一个节点的值大于后一个节点的值的情况，则说明链表没有排序好。

#include <stdio.h>
#include <stdbool.h>

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

bool isSorted(Node* head) {
    Node* current = head;
    while (current != NULL && current->next != NULL) {
        if (current->data > current->next->data) {
            return false;
        }
        current = current->next;
    }
    return true;
}

int main() {
    Node* head = NULL;
    Node* current = NULL;
    int data[] = {1, 2, 3, 4, 5};
    for (int i = 0; i < sizeof(data) / sizeof(data[0]); i++) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = data[i];
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            current = newNode;
        } else {
            current->next = newNode;
            current = newNode;
        }
    }
    printf("链表是否已排序：%sn", isSorted(head) ? "是" : "否");
    return 0;
}

3. 如果链表中存在重复的数据，如何对链表进行排序？

如果链表中存在重复的数据，可以使用排序算法时，在比较节点值大小的同时，考虑相等的情况。例如，可以使用冒泡排序算法时，当两个节点的值相等时，不进行交换操作，保持相对位置不变。

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

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

Node* bubbleSort(Node* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    Node* current;
    Node* lastSwapped = NULL;
    int swapped;
    do {
        swapped = 0;
        current = head;
        while (current->next != lastSwapped) {
            if (current->data > current->next->data) {
                int temp = current->data;
                current->data = current->next->data;
                current->next->data = temp;
                swapped = 1;
            }
            current = current->next;
        }
        lastSwapped = current;
    } while (swapped);
    return head;
}

int main() {
    Node* head = NULL;
    Node* current = NULL;
    int data[] = {3, 1, 2, 5, 2};
    for (int i = 0; i < sizeof(data) / sizeof(data[0]); i++) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = data[i];
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            current = newNode;
        } else {
            current->next = newNode;
            current = newNode;
        }
    }
    printf("排序前的链表：");
    current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("n");
    head = bubbleSort(head);
    printf("排序后的链表：");
    current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("n");
    return 0;
}

原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/1183864

赞 (0)
Edit1Edit1
上一篇 2024年8月30日 下午7:18
下一篇 2024年8月30日 下午7:18
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部