快速排序、单向链表的快速排序（C++）

最新推荐文章于 2022-11-01 16:19:43 发布

boom！！！

最新推荐文章于 2022-11-01 16:19:43 发布

阅读量3.3k

点赞数 1

分类专栏：算法 C++ 文章标签： C 快速排序单向链表快排复杂度

本文链接：https://blog.csdn.net/hgpenglin/article/details/83902019

版权

本文介绍了快速排序算法的基本思想，包括挖洞法和左右交换两种实现方式，并详细阐述了单向链表上如何应用快速排序，最后讨论了快速排序的平均和最坏情况下的时间复杂度。

摘要由CSDN通过智能技术生成

一、快速排序

取数组的第一个值作为基准值key，将数组中小于key的值排在key的左边，将数组中大于key的值排在key的右边，然后递归处理以key为分割的两个序列

（1）挖洞法。

a、挖洞法就是将数组Array第一个值作为基准值key保存（索引left和right分别指向序列的头和尾元素），索引right从右至左移动找到第一个小于key值的元素或者left等于right（left==right）时，将 Array[left] 值填入 Array[left] 的位置。

value	6（key）	2	4	9	7	10	3
index	0（left）	1	2	3	4	5	6（right）

value	3	2	4	9	7	10	3
index	0（left）	1	2	3	4	5	6（right）

b、然后再从left开始，left从左向右移动找到第一个大于key值的元素或者left等于right（left==right），将该元素值赋值给 Array[right]；

value	3	2	4	9	7	10	9
index	0	1	2	3（left）	4	5	6（right）

c、重复循环执行步骤a和b，直至left等于right（left==right）时结束循环，并将key赋值给 Array[left]；

value	3	2	4	9->6	7	10	9
index	0	1	2

最低0.47元/天解锁文章

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

boom！！！

关注关注

1
点赞
踩
10

收藏

觉得还不错? 一键收藏
3
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

c++基于链表的操作及排序

05-17

分为单向链表（每个节点只有一个指针，指向下一个节点）和双向链表（每个节点有两个指针，一个指向前一个节点，一个指向后一个节点）。 2. 链表节点定义：在C++中，我们通常用结构体或类来定义链表的节点，例如： `...

C++ 单链表快速排序

u014789533的博客

09-21

1万+

#include #include using namespace std; typedef struct Node { int data; Node * next; }Node; void swap(Node * A, Node *B) { coutdatadata<<endl; int temp= A->data; A->data=B->data; B->data=tem

3 条评论您还未登录，请先登录后发表或查看评论

C++实现对链表快速排序

weixin_53064820的博客

11-01

740

【代码】C++实现对链表快速排序。

基于顺序结构和单链表的各种排序算法C++实现

qq_40637903的博客

09-26

1610

1.直接插入排序时间复杂度O(n^2) 空间复杂度O(1) 稳定：不会改变相等元素的相对位置。适用于顺序存储和链式存储。算法描述： L[1…n] 初始L[1]是一个已经排好序的子序列；将L(i)(L[2…n])插入到已排好序的子序列：（1）查找出L(i)在L[1…i-1]中的位置k; （2）将L[k…i-1]中的所有元素后移一位；（3）将L(i)复制到L(k) 基于顺序存储的直接插入排序： //直接插入排序（顺序存储） void straisort(vector<int>&

C++ 五大链表排序（冒泡、插入、选择、归并、快排）

weixin_44178960的博客

08-18

5204

C++ 五大链表排序（冒泡、插入、选择、归并、快排）

【C++】快速排序以及归并排序的算法总结及思想应用分析

小黑同学的博客

10-20

769

【C++】快速排序以及归并排序的算法总结，并对两种算法从思想应用进行分析（力扣上的题目），最终对比了两个相似算法的特点

C++链表的排序实现

suren_jun的博客

10-18

5185

对于链表的排序算法，除了希尔排序之外，且堆排序不建议，其他排序方法都是支持的，如下：冒泡排序，选择排序，插入排序，归并排序，快速排序，计数排序，桶排序和基数排序。下面废话不多说。

C++ 排序双向循环链表代码

12-10

在C++中，为了实现排序功能，我们可以使用各种排序算法，例如冒泡排序、插入排序、选择排序或快速排序等。在这里，我们选择简单易懂的插入排序。插入排序的基本思想是将未排序的元素逐个插入到已排序的链表中。 ```...

c++算法集-排序-链表-图-队列-二叉树实现

05-08

链表分为单向链表和双向链表，前者只能从前往后遍历，后者则可以双向遍历。链表操作如插入、删除和查找通常比数组更灵活，但访问速度相对较慢。图算法是处理复杂关系的有效工具。图由节点和边组成，可以表示各种...

C++数据结构-线性表及相关查找排序算法

01-03

C++模板类实现的动态数组、双向循环链表、队列、栈等数据结构，以及基于迭代器的静态查找和排序算法，包括顺序查找、折半查找、简单选择排序（用于单向迭代器）、快速排序（双向迭代器）、堆排序（随机迭代器）。...

new_infor.rar_双向链表_电话簿类C++

09-23

双向链表是一种数据结构，它允许我们在列表中的每个元素前后进行导航，这与单向链表不同，后者只能向前遍历。双向链表在电话簿类的实现中很有用，因为它提供了一种高效的方式来添加、删除和查找联系人，同时还能保持...

单向链表操作详解（二）[The End]

rerli的专栏

12-08

7599

/*接着讲（测试编译时，请把相应的函数及测试代码放到上一讲代码的相关地方）：排序（选择、插入、冒泡）插入（有序）*//*===============================================作者：rerli时间：2003-12-08目的：学习单向链表的创建、修改、删除、插入（无序、有序）、输出、排序（选择、插入、冒泡）、反序说明：编译没有任何

基于单链表的快速排序算法（C++）

伊特

12-17

3841

考研倒计时4天，写个代码放松放松。国科大19年863最后一题数据结构大题：待排序列采用带头结点的单链表，写出在其上进行的快速排序的递归算法。算法思想：快排核心思想是每一趟确定一个基元素的最终位置，小于它的在左边，大于它的在右边。题目给了单链表，那就没办法随机访问，但是不影响将一段链表分为两段的操作，那就用几个指针通过一次遍历将一段链表分为两段，然后基元素放中间，最后递归左右两段链表就行了。...

C++链表排序（归并法+快速排序）

qq_41884662的博客

04-18

6657

我们可以试用归并排序解决：对链表归并排序的过程如下。找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2 步，慢指针每次移动 1步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。对两个子链表分别排序。将两个排序后的子链表合并，得到完整的排序后的链表上述过程可以通过递归实现。递归的终止条件是链表的节点个数小于或等于 1，即当链表为空或者链表只包含 1 个节点时，不需要对链表进行拆分和排序。 class Solution { .

C语言 单向链表 及其排序

weixin_43667308的博客

12-19

1万+

#include<stdio.h> #include<malloc.h> #define LEN sizeof(struct Student) struct Student //结构体声明 { long num; int score; struct Student* next; }; int n; struct Studen...

单向链表排序

qq_43449554的博客

02-15

1369

一、冒泡排序简述 1、概念冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。　　它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。 2、实例分析以数组为例进行说明：　　数组a[4] = {4,...

leetCode中java实现归并排序

yyywww666的专栏

05-09

532

Sort a linked list in O(n log n) time using constant space complexity. 考虑到时间复杂度为O(nlogn)的排序算法有：快速排序，归并排序，堆排序和希尔排序，而适合用链表实现的应该是归并排序归并排序算法介绍：归并排序（Merge Sort）完全遵循上述分治法三个步骤： 1、分解：将要排序的n个元

单向链表的实现--排序

奋斗的菜鸟博客

06-15

1640

在讲解单向链表排序之前，我们先用快速排序算法对一个数组的元素从小到大进行排序，然后输出打印显示，快速排序算法不清楚的先自己查资料学习了解，这里不对算法进行讲解。

单链表的快速排序

最新发布

04-05

以下是单向链表的快速排序的C语言实现： ```c #include <stdio.h> #include <stdlib.h> // 定义链表结构体 typedef struct Node { int value; struct Node* next; } Node; // 创建链表节点 Node* createNode(int value) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->value = value; newNode->next = NULL; return newNode; } // 将链表拆分成小于和大于pivot的两个链表 void partition(Node* head, int pivot, Node** lessHead, Node** greaterHead) { Node* lessTail = NULL; Node* greaterTail = NULL; Node* curr = head; while (curr != NULL) { Node* next = curr->next; if (curr->value < pivot) { if (*lessHead == NULL) { *lessHead = curr; lessTail = curr; lessTail->next = NULL; } else { lessTail->next = curr; lessTail = curr; lessTail->next = NULL; } } else { if (*greaterHead == NULL) { *greaterHead = curr; greaterTail = curr; greaterTail->next = NULL; } else { greaterTail->next = curr; greaterTail = curr; greaterTail->next = NULL; } } curr = next; } } // 快速排序 Node* quickSort(Node* head) { if (head == NULL || head->next == NULL) { return head; } Node* lessHead = NULL; Node* greaterHead = NULL; // 将链表拆分成小于和大于pivot的两个链表 partition(head->next, head->value, &lessHead, &greaterHead); // 递归快排小于和大于pivot的两个链表 lessHead = quickSort(lessHead); greaterHead = quickSort(greaterHead); // 将小于pivot的链表和大于pivot的链表连接起来 head->next = greaterHead; if (lessHead == NULL) { return head; } Node* curr = lessHead; while (curr->next != NULL) { curr = curr->next; } curr->next = head; return lessHead; } // 打印链表 void printList(Node* head) { while (head != NULL) { printf("%d ", head->value); head = head->next; } printf("\n"); } int main() { Node* head = createNode(5); head->next = createNode(3); head->next->next = createNode(8); head->next->next->next = createNode(4); head->next->next->next->next = createNode(2); printf("Before sorting: "); printList(head); head = quickSort(head); printf("After sorting: "); printList(head); return 0; } ``` 输出： ``` Before sorting: 5 3 8 4 2 After sorting: 2 3 4 5 8 ``` 这里的快速排序算法的时间复杂度是O(nlogn)，空间复杂度是O(1)，其中n是链表的长度。