1. PingCode智库首页
  2. 百科

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

Edit1 • • 百科

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

在C语言中对链表进行排序，可以使用多种方法，包括冒泡排序、插入排序和归并排序。 其中，归并排序通常是最有效的，因为它具有O(n log n)的时间复杂度，并且可以在链表上实现稳定排序。接下来，我们将详细讨论归并排序在链表中的实现。

一、链表排序的基本概念

链表是一种动态数据结构，由一系列节点组成，每个节点包含数据和一个指向下一个节点的指针。由于链表的动态性，它在插入和删除操作上比数组更具优势，但在排序时稍显复杂。常见的链表排序方法有：

  1. 冒泡排序：通过相邻元素的比较和交换来排序，时间复杂度为O(n^2)。
  2. 插入排序：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描找到相应位置并插入，时间复杂度为O(n^2)。
  3. 归并排序：采用分治策略，将链表递归地拆分成两个子链表，对子链表排序后再合并，时间复杂度为O(n log n)。

归并排序由于其效率和稳定性，常用于链表的排序。

二、归并排序的实现步骤

归并排序主要分为三个步骤：分割链表、排序子链表、合并子链表。

1. 分割链表

首先，我们需要将链表分割为两个子链表。为了实现这一点，可以使用快慢指针法：快指针每次走两步，慢指针每次走一步，当快指针到达链表末尾时，慢指针正好位于链表的中间位置。

struct Node* split(struct Node* head) {


    struct Node* fast = head;


    struct Node* slow = head;


    struct Node* prev = NULL;


    while (fast != NULL && fast->next != NULL) {


        fast = fast->next->next;


        prev = slow;


        slow = slow->next;


    }


    if (prev != NULL) {


        prev->next = NULL;


    }


    return slow;


}

2. 排序子链表

对于每个子链表，我们递归地调用归并排序函数。

struct Node* mergeSort(struct Node* head) {


    if (head == NULL || head->next == NULL) {


        return head;


    }


    struct Node* middle = split(head);


    struct Node* left = mergeSort(head);


    struct Node* right = mergeSort(middle);


    return merge(left, right);


}

3. 合并子链表

最后，需要合并两个已经排序的子链表。这个过程类似于归并排序中的合并步骤。

struct Node* merge(struct Node* left, struct Node* right) {


    if (left == NULL) {


        return right;


    }


    if (right == NULL) {


        return left;


    }


    struct Node* result = NULL;


    if (left->data <= right->data) {


        result = left;


        result->next = merge(left->next, right);


    } else {


        result = right;


        result->next = merge(left, right->next);


    }


    return result;


}

三、完整代码示例

以下是完整的链表归并排序的实现代码：

#include <stdio.h>


#include <stdlib.h>


struct Node {


    int data;


    struct Node* next;


};


struct Node* split(struct Node* head) {


    struct Node* fast = head;


    struct Node* slow = head;


    struct Node* prev = NULL;


    while (fast != NULL && fast->next != NULL) {


        fast = fast->next->next;


        prev = slow;


        slow = slow->next;


    }


    if (prev != NULL) {


        prev->next = NULL;


    }


    return slow;


}


struct Node* merge(struct Node* left, struct Node* right) {


    if (left == NULL) {


        return right;


    }


    if (right == NULL) {


        return left;


    }


    struct Node* result = NULL;


    if (left->data <= right->data) {


        result = left;


        result->next = merge(left->next, right);


    } else {


        result = right;


        result->next = merge(left, right->next);


    }


    return result;


}


struct Node* mergeSort(struct Node* head) {


    if (head == NULL || head->next == NULL) {


        return head;


    }


    struct Node* middle = split(head);


    struct Node* left = mergeSort(head);


    struct Node* right = mergeSort(middle);


    return merge(left, right);


}


void push(struct Node head_ref, int new_data) {


    struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));


    new_node->data = new_data;


    new_node->next = (*head_ref);


    (*head_ref) = new_node;


}


void printList(struct Node* node) {


    while (node != NULL) {


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


        node = node->next;


    }


}


int main() {


    struct Node* res = NULL;


    push(&res, 15);


    push(&res, 10);


    push(&res, 5);


    push(&res, 20);


    push(&res, 3);


    push(&res, 2);


    printf("Unsorted Linked List: n");


    printList(res);


    res = mergeSort(res);


    printf("nSorted Linked List: n");


    printList(res);


    return 0;


}

四、其他排序方法

虽然归并排序非常适合链表，但在某些情况下，其他排序方法可能更适用。接下来，我们简要介绍冒泡排序和插入排序在链表中的实现。

冒泡排序

冒泡排序是一种简单但效率较低的排序算法，其时间复杂度为O(n^2)。在链表上实现冒泡排序，需要反复遍历链表，比较相邻节点并交换它们的值。

void bubbleSort(struct Node *start) {


    int swapped, i;


    struct Node *ptr1;


    struct Node *lptr = NULL;


    if (start == NULL) {


        return;


    }


    do {


        swapped = 0;


        ptr1 = start;


        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);


}

插入排序

插入排序在链表上的实现较为简单。我们从未排序部分中取出一个节点，并将其插入到已排序部分的适当位置。

void insertionSort(struct Node head_ref) {


    struct Node *sorted = NULL;


    struct Node *current = *head_ref;


    while (current != NULL) {


        struct Node *next = current->next;


        sortedInsert(&sorted, current);


        current = next;


    }


    *head_ref = sorted;


}


void sortedInsert(struct Node head_ref, struct Node *new_node) {


    struct Node *current;


    if (*head_ref == NULL || (*head_ref)->data >= new_node->data) {


        new_node->next = *head_ref;


        *head_ref = new_node;


    } else {


        current = *head_ref;


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


            current = current->next;


        }


        new_node->next = current->next;


        current->next = new_node;


    }


}

五、选择合适的排序算法

选择合适的排序算法取决于具体情况：

  1. 链表长度：对于较短的链表，冒泡排序和插入排序可能足够。
  2. 稳定性要求：如果需要稳定排序，归并排序是最佳选择。
  3. 时间复杂度：归并排序的O(n log n)时间复杂度使其成为处理较大链表的理想选择。

六、总结

在C语言中对链表进行排序，归并排序是最常用且高效的算法。我们详细介绍了归并排序的实现步骤，并提供了完整的代码示例。此外，还简要介绍了冒泡排序和插入排序的实现。选择合适的排序算法应根据链表长度、稳定性要求和时间复杂度等因素进行综合考虑。

七、项目管理系统的推荐

在进行软件开发和项目管理时，使用合适的项目管理系统可以大大提高效率。推荐使用以下两个系统：

  1. 研发项目管理系统PingCode：专为研发团队设计，提供全面的项目管理解决方案。
  2. 通用项目管理软件Worktile：适用于各种类型的项目管理，功能丰富且易于使用。

通过使用这些系统，可以更好地管理项目进度、任务分配和团队协作，从而提高整体工作效率。

相关问答FAQs：

Q: 如何使用C语言对链表进行排序？

A: 对链表进行排序的常见方法是使用冒泡排序、插入排序或选择排序等经典排序算法。以下是一个使用冒泡排序对链表进行排序的示例代码：

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

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

void bubbleSort(struct Node* head) {
    int swapped;
    struct Node* ptr1;
    struct Node* lptr = NULL;

    if (head == NULL) {
        return;
    }

    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);
}

int main() {
    // 创建链表
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    struct Node* second = (struct Node*)malloc(sizeof(struct Node));
    struct Node* third = (struct Node*)malloc(sizeof(struct Node));

    head->data = 3;
    head->next = second;
    second->data = 2;
    second->next = third;
    third->data = 1;
    third->next = NULL;

    // 排序前的链表
    printf("排序前的链表：n");
    struct Node* ptr = head;
    while (ptr != NULL) {
        printf("%d ", ptr->data);
        ptr = ptr->next;
    }

    // 对链表进行排序
    bubbleSort(head);

    // 排序后的链表
    printf("n排序后的链表：n");
    ptr = head;
    while (ptr != NULL) {
        printf("%d ", ptr->data);
        ptr = ptr->next;
    }

    return 0;
}

Q: C语言中有哪些常用的排序算法可以用来对链表进行排序？

A: C语言中常用的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等。这些排序算法都可以用来对链表进行排序，具体选择哪种算法取决于链表的大小和排序需求。

Q: 如何使用选择排序对链表进行排序？

A: 使用选择排序对链表进行排序的步骤如下：

  1. 遍历链表，找到最小的节点。
  2. 将最小节点与链表的头节点交换位置。
  3. 将头节点后面的链表部分再次进行选择排序。
  4. 重复上述步骤，直到链表排序完成。

以下是一个使用选择排序对链表进行排序的示例代码：

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

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

void selectionSort(struct Node* head) {
    struct Node* current = head;
    struct Node* index = NULL;
    int temp;

    if (head == NULL) {
        return;
    }

    while (current != NULL) {
        index = current->next;

        while (index != NULL) {
            if (current->data > index->data) {
                temp = current->data;
                current->data = index->data;
                index->data = temp;
            }
            index = index->next;
        }
        current = current->next;
    }
}

int main() {
    // 创建链表
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    struct Node* second = (struct Node*)malloc(sizeof(struct Node));
    struct Node* third = (struct Node*)malloc(sizeof(struct Node));

    head->data = 3;
    head->next = second;
    second->data = 2;
    second->next = third;
    third->data = 1;
    third->next = NULL;

    // 排序前的链表
    printf("排序前的链表：n");
    struct Node* ptr = head;
    while (ptr != NULL) {
        printf("%d ", ptr->data);
        ptr = ptr->next;
    }

    // 对链表进行排序
    selectionSort(head);

    // 排序后的链表
    printf("n排序后的链表：n");
    ptr = head;
    while (ptr != NULL) {
        printf("%d ", ptr->data);
        ptr = ptr->next;
    }

    return 0;
}

希望以上内容能够帮助到您，如果还有其他问题，请随时提问。

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

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

4008001024

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