单向链表排序：快速排序和归并排序

最新推荐文章于 2022-11-27 19:29:34 发布
最新推荐文章于 2022-11-27 19:29:34 发布
阅读量5.6k 收藏 10
点赞数 2
分类专栏： 排序算法 文章标签： 链表 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quzhongxin/article/details/48087685
版权

对单向链表的排序有2种形式，只改变节点的值 和 只改变链接

// 节点
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int v, ListNode* n = NULL) {
        val = v;
        next = n;
    }
};

本文链接：单向链表排序：快速排序和归并排序

参考资料链接：
链表排序（冒泡、选择、插入、快排、归并、希尔、堆排序）：

1. 归并排序（改变链接）

归并排序是最适合单链表排序的算法，因为两个链表的归并比较简单，和数组的归并过程思路相同。
需要注意的是：如何找到链表的中点？
通过2个快慢指针，快指针每一步走2个节点，慢指针每一步走1个节点，当快指针到达链表尾部时，慢指针到达链表的中间节点。

class MergeSort {
public:
    static ListNode* ListMergeSort(ListNode* pHead) {
        if (pHead == NULL || pHead->next == NULL)
            return pHead;
        ListNode* pFast = pHead;
        ListNode* pSlow = pHead;
        // 找到位于中间的节点，快慢指针，快的到结尾，慢的到中点
        while (pFast != NULL && pFast->next == NULL) {
            pFast = pFast->next->next;
            pSlow = pSlow->next;
        }
        pFast = pSlow;
        pSlow = pSlow->next; // 分割成2段
        pFast->next = NULL;
        pHead = ListMergeSort(pHead);
        pSlow = ListMergeSort(pSlow);
        pHead = merge(pHead, pSlow);
        return pHead;
    };
private:
    static ListNode* merge(ListNode* pHead1, ListNode* pHead2) {
        if (pHead1 == NULL || pHead2 == NULL) {
            return pHead1 == NULL ? pHead2 : pHead1;
        }
        // 找出合并后的链表头
        ListNode* pHead = NULL;
        if (pHead1->val > pHead2->val) {
            pHead = pHead2;
            pHead2 = pHead2->next;
        } else {
            pHead = pHead1;
            pHead1 = pHead1->next;
        }
        // 将2个链表中值较小的节点依次链接到结果链表中
        ListNode* pHead_orgin = pHead;
        while (pHead1 != NULL && pHead2 != NULL) {
            if (pHead1->val > pHead2->val) {
                pHead->next = pHead2;
                pHead2 = pHead2->next;
            } else {
                pHead->next = pHead1;
                pHead1 = pHead1->next;
            }
            pHead = pHead->next;
        }
        if (pHead1 == NULL)
            pHead->next = pHead2;
        else
            pHead->next = pHead1;
        return pHead_orgin;
    };
};

2. 快速排序（改变链接）

只改变链接的指向。
将比基元（第一个节点）小的值，链接到一个左链表中；比基元大的值，链接到一个右链表中；
将左链表，基元，右链表链接起来。

对一段链表执行划分过程时，头节点可能发生改变以及终止节点可能是非空的，因此对一段链表的划分过程需要给出：
前驱节点（指向头节点）和终止节点（标志结束）。
故对传入划分函数的一次链表划分处理是不包括第一个节点和最后一个节点的。（双开区间）

class QuickSort {
public:
    static ListNode* ListQuickSort(ListNode* pHead) {
        if (pHead == NULL || pHead->next == NULL)
            return pHead;
        ListNode headPrev(0, pHead); // pHead 的前驱节点
        ListQuickSort(&headPrev, pHead, NULL);
        return headPrev.next;
    }
private:
    static void ListQuickSort(ListNode* pHeadPrev, ListNode* pHead, ListNode* pTail) {
        // 处理过程不涉及 pHeadPrev 和 pTail
        if (pHead == pTail || pHead->next == pTail)
            return;
        ListNode* pMid = Partation(pHeadPrev, pHead, pTail);
        ListQuickSort(pHeadPrev, pHeadPrev->next, pMid);
        ListQuickSort(pMid, pMid->next, pTail);
    };

    static ListNode* Partation(ListNode* pHeadPrev, ListNode* pHead, ListNode* pTail) {
        int key = pHead->val; // 选第一个节点为基元
        ListNode nodeL(0), nodeR(0);
        ListNode* pLeftPrev = &nodeL; // 小于基元的链表
        ListNode* pRightPrev = &nodeR; // 大于等于基元的链表
        for (ListNode* pNode = pHead->next; pNode != pTail; pNode = pNode->next) {
            if (pNode->val < key) {
                pLeftPrev->next = pNode;
                pLeftPrev = pNode;
            } else {
                pRightPrev->next = pNode;
                pRightPrev = pNode;
            }
        }
        pRightPrev->next = pTail; // 保证子链表继续和后面的相连
        pLeftPrev->next = pHead; // 基元节点链接
        pHead->next = nodeR.next;
        pHeadPrev->next = nodeL.next; // 链表头节点
        return pHead;
    };
};

3. 快速排序（改变节点值）

由于链表只能顺序索引，故不能使用数组划分的方法。
将比基元小的节点的值，依次和基元后的节点的值交换。
如 5->3->6->4->7->2
则 5 为基元
3 < 5: swap(3, 3) ，(起始交换位置为基元的下一个节点，即第2个节点)
6 > 5: continue;
4 < 5: swap(6, 4) （交换位置后移，交换4和第3个节点的值）
7 > 5: continue
2 < 5: swap(4, 2) （交换位置后移，交换2和第4个节点的值）

循环结束 swap(5, 2) （交换基元值和第4个节点的值）

最后得到：2->3->4->5->6->7

class QuickSortValue {
public:
    static void QuickSort(ListNode* pHead) {
        if (pHead == NULL || pHead->next == NULL)
            return;
        QuickSort(pHead, NULL);
    }
private:
    static void QuickSort(ListNode* pHead, ListNode* pTail) {
        if (pHead == pTail || pHead->next == pTail)
            return;
        ListNode* pMid = Partation(pHead, pTail);
        QuickSort(pHead, pMid);
        QuickSort(pMid->next, pTail);
    }
    static ListNode* Partation(ListNode* pHead, ListNode* pTail) {
        if (pHead == pTail || pHead->next == pTail)
            return pHead;
        ListNode* pPivot = pHead; // 基元
        int key = pHead->val;
        for (ListNode* pNode = pHead->next; pNode != pTail; pNode = pNode->next) {
            if (pNode->val < key) {
                pPivot = pPivot->next; // 将比基元小的值，依次交换到前面
                swap(pNode, pPivot);
            }
        }
        swap(pHead, pPivot);
        return pPivot;
    }
    static void swap(ListNode* pA, ListNode* pB) {
        int temp = pA->val; pA->val = pB->val; pB->val = temp;
    }
};

4. 所有源码和测试函数

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int v, ListNode* n = NULL) {
        val = v;
        next = n;
    }
};
void PrintList(ListNode* pHead) {
    while (pHead != NULL) {
        cout << pHead->val << " ";
        pHead = pHead->next;
    }
    cout << endl;
    return;
}
class MergeSort {
public:
    static ListNode* ListMergeSort(ListNode* pHead) {
        if (pHead == NULL || pHead->next == NULL)
            return pHead;
        ListNode* pFast = pHead;
        ListNode* pSlow = pHead;
        // 找到位于中间的节点，快慢指针，快的到结尾，慢的到中点
        while (pFast != NULL && pFast->next == NULL) {
            pFast = pFast->next->next;
            pSlow = pSlow->next;
        }
        pFast = pSlow;
        pSlow = pSlow->next; // 分割成2段
        pFast->next = NULL;
        pHead = ListMergeSort(pHead);
        pSlow = ListMergeSort(pSlow);
        pHead = merge(pHead, pSlow);
        return pHead;
    };
private:
    static ListNode* merge(ListNode* pHead1, ListNode* pHead2) {
        if (pHead1 == NULL || pHead2 == NULL) {
            return pHead1 == NULL ? pHead2 : pHead1;
        }
        // 找出合并后的链表头
        ListNode* pHead = NULL;
        if (pHead1->val > pHead2->val) {
            pHead = pHead2;
            pHead2 = pHead2->next;
        } else {
            pHead = pHead1;
            pHead1 = pHead1->next;
        }
        ListNode* pHead_orgin = pHead;
        while (pHead1 != NULL && pHead2 != NULL) {
            if (pHead1->val > pHead2->val) {
                pHead->next = pHead2;
                pHead2 = pHead2->next;
            } else {
                pHead->next = pHead1;
                pHead1 = pHead1->next;
            }
            pHead = pHead->next;
        }
        if (pHead1 == NULL)
            pHead->next = pHead2;
        else
            pHead->next = pHead1;
        return pHead_orgin;
    };
};

class QuickSort {
public:
    static ListNode* ListQuickSort(ListNode* pHead) {
        if (pHead == NULL || pHead->next == NULL)
            return pHead;
        ListNode headPrev(0, pHead); // pHead 的前驱节点
        ListQuickSort(&headPrev, pHead, NULL);
        return headPrev.next;
    }
private:
    static void ListQuickSort(ListNode* pHeadPrev, ListNode* pHead, ListNode* pTail) {
        if (pHead == pTail || pHead->next == pTail)
            return;
        ListNode* pMid = Partation(pHeadPrev, pHead, pTail);
        ListQuickSort(pHeadPrev, pHeadPrev->next, pMid);
        ListQuickSort(pMid, pMid->next, pTail);
    };

    static ListNode* Partation(ListNode* pHeadPrev, ListNode* pHead, ListNode* pTail) {
        int key = pHead->val; // 选第一个节点为基元
        ListNode nodeL(0), nodeR(0);
        ListNode* pLeftPrev = &nodeL;
        ListNode* pRightPrev = &nodeR;
        for (ListNode* pNode = pHead->next; pNode != pTail; pNode = pNode->next) {
            if (pNode->val < key) {
                pLeftPrev->next = pNode;
                pLeftPrev = pNode;
            } else {
                pRightPrev->next = pNode;
                pRightPrev = pNode;
            }
        }
        pRightPrev->next = pTail; // 保证子链表继续和后面的相连
        pLeftPrev->next = pHead; // 基元节点链接
        pHead->next = nodeR.next;
        pHeadPrev->next = nodeL.next;
        return pHead;
    };
};

class QuickSortValue {
public:
    static void QuickSort(ListNode* pHead) {
        if (pHead == NULL || pHead->next == NULL)
            return;
        QuickSort(pHead, NULL);
    }
private:
    static void QuickSort(ListNode* pHead, ListNode* pTail) {
        if (pHead == pTail || pHead->next == pTail)
            return;
        ListNode* pMid = Partation(pHead, pTail);
        QuickSort(pHead, pMid);
        QuickSort(pMid->next, pTail);
    }
    static ListNode* Partation(ListNode* pHead, ListNode* pTail) {
        if (pHead == pTail || pHead->next == pTail)
            return pHead;
        ListNode* pPivot = pHead; // 基元
        int key = pHead->val;
        for (ListNode* pNode = pHead->next; pNode != pTail; pNode = pNode->next) {
            if (pNode->val < key) {
                pPivot = pPivot->next; // 将比基元小的值，依次交换到前面
                swap(pNode, pPivot);
            }
        }
        swap(pHead, pPivot);
        return pPivot;
    }
    static void swap(ListNode* pA, ListNode* pB) {
        int temp = pA->val; pA->val = pB->val; pB->val = temp;
    }
};

int main() 
{
    srand(time(0));
    const int N = 30;
    ListNode* pHead = NULL;
    for (int i = 0; i < N; i++) {
        if (pHead == NULL) {
            pHead = new ListNode(rand() % 100 + 1, NULL);
        }
        else {
            ListNode* tempNode = new ListNode(rand() % 100 + 1, pHead);
            pHead = tempNode;
        }
    }
    PrintList(pHead);
    pHead = MergeSort::ListMergeSort(pHead); // merge-sort
   // pHead = QuickSort::ListQuickSort(pHead); // quick-sort-swap-node
   //QuickSortValue::QuickSort(pHead); // quick-sort-swap-value
    PrintList(pHead);
}
曲小鑫
关注
专栏目录
c++基于链表的操作及排序
05-17
4. 归并排序：采用分治法，将链表分成两半，分别排序后再合并，效率较高。 四、链表排序实例——归并排序 归并排序在链表上的实现步骤： 1. 分解：将链表分成两个大致相等的部分。 2. 排序：递归地对两部分进行归并...
单向链表中的数据排序问题
zswsx123的博客
01-26 1978
文章目录前言一、单向链表中数据排序问题的解决方案二、方法优劣比较1.运用GetTickCount()函数来记录两种方法在同一长度链表排序中的时间2.记录结果和比较总结 前言 在利用单链表做学生信息管理系统的时候发现了一个一直忽略一个问题，就是在单链表中如何进行排序的问题，我们知道在顺序表中可以很轻易的利用冒泡排序或者归并排序等各种算法轻易实现排序，但在单链表中该如何进行排序引起了我的思考。在一番思索过后，我暂时给出了两种基本的解决方案，这两种方案我都放在了之前的一篇文章中，详细代码可以参考数据结构——（.
单向链表的三种排序算法---快速排序，归并排序，插入排序
qq_22158743的博客
08-01 1887
给链表排序是面试中常考的一道题，今天总结一些经常链表排序的三种常用算法。分别是：快速排序、归并排序和插入排序。 快速排序 数组的快速排序相必大家都烂熟于心了，很简单，就是选定一个pivot，然后将大于等于pivot的排在pivot的右边，下雨pivot的排在pivot的左边。这样pivot的最终顺序就确定好了，接下来只需要对pivot的左边和右边执行相同的过程即可。 代码如下：...
单向链表排序
qq_43449554的博客
02-15 1374
一、冒泡排序简述 1、概念 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 　　它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。 2、实例分析 以数组为例进行说明： 　　数组a[4] = {4,...
单链表排序
热门推荐
LSGOZJ的博客
09-03 5万+
前言：最近总结了一下针对只有头结点的单链表进行排序的几个简单的方法。交换节点：插入排序，冒泡排序，简单选择排序 交换数据：快速排序初始化：#include <stdio.h> #include <stdlib.h> #include <stdbool.h>//节点结构 struct node { int val; struct node * next; }; typedef str
单向链表的排序（使用冒泡排序交换节点）
莞工杰仔的博客
12-26 4615
文章内容： 第一点：首先我们谈一谈有关链表的储存问题，首先我希望大家记住一各准则：链表的头指针尽量不要用来存储数据，为什么？因为这样会使你处理数据时更加的方便，方便在哪里？如果头指针不放数据的话，那么你在处理数据的时候，就可以将所有数据都统一对待？有的同学可能会有疑惑，结合排序说一下吧？排序的话其实就是改变各链节中的指针的指向，因为你链表的本质就是通过指针将多个链节（结构体）连接在一起，而排序就是改变链节的先后顺序，而改变它的顺序就是要改变其前后连接的的指针的指向。好讲到这里我问再回到我们最开始的问题：为什
JS常用的数据结构和算法,链表、栈、队列、排序和查找:octocat
04-03
链表分为单向链表和双向链表。在JavaScript中，可以使用对象来表示节点，包含数据属性和指向下一个节点的next属性。 **栈** 栈是一种后进先出（LIFO）的数据结构，类似于现实中的堆叠物品。添加和移除元素都在栈顶...
按照百十个位分拆链表，然后组合排序
05-06
虽然这种方法可能不如其他通用的排序算法（如快速排序、归并排序等）高效，但它提供了一种新的思路，特别是在处理特定类型的数据时。对于学习数据结构和算法的人来说，这是一种非常有价值的实践和探索。
个人C语言学习实录练习题-链表.数据结构.快速排序练习.rar
最新发布
05-22
快速排序的时间复杂度平均为O(n log n)，最坏情况下为O(n^2)，但实际应用中效率往往高于其他O(n log n)算法，如归并排序。 通过本压缩包中的练习题，学习者可以实践C语言中的链表操作，比如创建链表、插入、删除、...
链表 和 数组 的一些简单操作 包括排序 插入 删除
08-17
3. **排序**：数组可以使用各种排序算法进行排序，如冒泡排序、选择排序、插入排序、快速排序、归并排序等。不同的排序算法有不同的时间复杂度和空间复杂度。 链表也是线性数据结构，但它在内存中不一定是连续存储...
Project1：演示链表和排序算法的使用以及操作员重载
02-13
常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。在这个项目中，你可能会被要求实现一种或多种排序算法，并用它们来对链表中的元素进行排序。比如，你可以使用插入排序，通过比较相邻元素并...
C语言单双向链表的增删改查以及排序问题完整代码
09-04
3. **快速排序**：选择一个“基准”节点，将链表分为小于和大于基准的两部分，递归排序这两部分。 4. **堆排序**：建立大顶堆或小顶堆，然后将堆顶元素与末尾元素交换，缩小堆的大小，直到只剩一个元素。 需要注意...
数据结构链表树图查找排序
09-20
链表有多种类型，如单向链表、双向链表和循环链表。链表的主要操作包括插入、删除和遍历，由于不需要在内存中保持连续性，因此插入和删除操作通常比数组更高效。 2. **树**：树是一种非线性的数据结构，由节点和边...
python链表、栈、队列、排序算法代码
03-26
- **快速排序**（快速排序.py）：使用分治策略，选择一个基准值，将数组分为小于基准值和大于基准值两部分，再对两部分进行快速排序，平均时间复杂度为O(n log n)。 - **归并排序**（归并排序.py）：也是分治策略...
冒泡排序(单向、双向)
05-28
在实际开发中，更常使用的排序算法有快速排序、归并排序等，它们具有更好的时间复杂度和性能表现。 总结来说，冒泡排序是初学者理解排序算法的良好起点，它简单易懂，但效率较低。单向冒泡排序是最基础的形式，而...
单向链表操作详解（二）[The End]
rerli的专栏
12-08 7601
/*接着讲（测试编译时，请把相应的函数及测试代码放到上一讲代码的相关地方）：排序（选择、插入、冒泡）插入（有序）*//*===============================================作者：rerli时间：2003-12-08目的：学习单向链表的创建、修改、删除、  插入（无序、有序）、输出、  排序（选择、插入、冒泡）、反序说明：编译没有任何
单链表的排序操作
qq_45917176的博客
06-30 6932
数据结构--单链表的排序操作
【数据结构与算法】单链表的排序算法(选择，冒泡，递归）
摸鱼小小虫的博客
11-27 6908
链表的选择排序思想与数组的排序类似，但是链表需要先找到里面最小或者最大的值，然后将这个值用改链语句进行操作。接下来我们进行排序，首先选取一个基准点，如何将比基准点大/小的值放左边，比基准点小/大的放右边。我们先看这个改链语句的操作（min是笔者打错了应该是max，但是图已经画好了就没有改）移动q这个指针找到最大的min，然后利用i保存q的前一个节点这样就能找到min_on.数组快速排序的思想和链表的一样，主要问题就是存在改链的操作。然后我们就可以将链表进行排序了，完整的代码如下。此时我们将2下沉到底部；
单链表的排序
F13253524870的博客
06-03 4464
题目 给定一个无序单链表，实现单链表的排序(按升序排序)。 示例1 输入： [1,3,2,4,5] 返回值： {1,2,3,4,5} 分析 第一种：直接插入排序，不同与数组的直接插入排序，链表的直接排序从前往后寻找插入位置。 public ListNode sortInList (ListNode head) { // write code here if(head == null) { return null; }
单向链表排序c++头歌
09-23
单向链表排序可以通过不同的排序算法来实现，比如冒泡排序、插入排序、选择排序、归并排序和快速排序等。下面以冒泡排序为例进行说明。 冒泡排序是一种简单的排序算法，它重复地遍历链表，并通过两个相邻节点的比较来交换节点的位置，直到整个链表有序为止。具体实现步骤如下： 1. 设置两个指针，一个指向链表的头节点，另一个指向头节点的下一个节点。 2. 遍历链表，比较当前节点和下一个节点的值，如果需要交换位置则交换。 3. 继续遍历链表，直到指针指向链表的尾节点。 4. 如果有任何节点交换了位置，则重新开始遍历链表，直到没有节点需要交换位置为止。 5. 链表排序完成。 下面是使用C语言实现的单向链表排序代码： ```c #include <stdio.h> // 定义链表节点结构 struct ListNode { int val; struct ListNode *next; }; // 冒泡排序函数 void bubbleSort(struct ListNode *head) { if (head == NULL || head->next == NULL) { return; } int swapped; struct ListNode *ptr1; struct ListNode *lptr = NULL; do { swapped = 0; ptr1 = head; while (ptr1->next != lptr) { if (ptr1->val > ptr1->next->val) { // 交换节点位置 int tmp = ptr1->val; ptr1->val = ptr1->next->val; ptr1->next->val = tmp; swapped = 1; } ptr1 = ptr1->next; } lptr = ptr1; } while (swapped); } // 测试用例 int main() { // 创建链表 struct ListNode n1, n2, n3, n4; n1.val = 4; n2.val = 2; n3.val = 1; n4.val = 3; n1.next = &n2; n2.next = &n3; n3.next = &n4; n4.next = NULL; // 排序链表 bubbleSort(&n1); // 输出排序结果 struct ListNode *ptr = &n1; while (ptr != NULL) { printf("%d ", ptr->val); ptr = ptr->next; } return 0; } ``` 以上代码中，我们首先定义了一个链表节点结构 `struct ListNode`，包含一个整数值 `val` 和一个指向下一个节点的指针 `next`。然后我们使用冒泡排序算法实现了 `bubbleSort` 函数，最后在 `main` 函数中创建了一个测试用例并进行排序输出。输出结果为 `1 2 3 4`，表示链表已经按照从小到大的顺序进行了排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值