数据结构学习笔记06排序 (快速排序、表排序、基数排序)
1.快速排序
不稳定
分而治之
找主元pivot，小于主元划分为一个子集，大于主元的划分为一个子集
然后进行递归
最好情况：每次主元正好中分，T(N) = O( NlogN )
选主元 的方法有很多，这里用 取头、中、尾的中位数。
直接选A[0]为pivot，时间复杂度T ( N ) = O( N ) + T ( N–1 ) = O( N ) + O ( N–1 ) + T( N–2 ) = = O( N ) + O ( N–1 ) + …+ O( 1 ) = O( N^2 )
随机取pivot：rand()函数 也很费
取头、中、尾的中位数……
子集划分
i指向8,j指向7.
8>6,i不动,7>6,j--;j指向2,2<6,j不动 交换8和2;
i++,i指向1,1<6,i++;i指向4,4<6,i++;i指向9,9>6,i不动;
j--,j指向5,5<6，j不动，交换5和9;
i++,i指向0,0<6,i++;i指向3,3<6,i++;i指向9,9>6,i不动;
j--,j指向3,3<6,j不动.
i>j,结束,6放到i位置，即6和9交换
如果有元素正好等于pivot怎么办：
停下来交换：会产生很多不必要的交换。(一串相等的序列)
不理它，继续移动指针：pivot位置靠近一段，最糟糕会在最右边端，和pivot取A[0]一样，O( N^2 )
综合考虑，选第一种，停下来交换。
小规模数据的处理
快速排序的问题
用递归……
对小规模的数据（例如N不到100）可能还不如插入排序快
解决方案
当递归的数据规模充分小，则停止递归，直接调用简单排序（例如插入排序）
在程序中定义一个Cutoff的阈值
1 #include <stdio.h>
2 typedef int ElementType;
3
4 void Swap( ElementType *a, ElementType *b )
5 {
6 ElementType t = *a;
7 *a = *b;
8 *b = t;
9 }
10
11 void InsertionSort(ElementType A[], int N)
12 {
13 int i;
14 for (int P = 1; P < N; P++ ) {
15 ElementType temp = A[P]; //取出未排序序列中第一个元素
16 for (i = P; i > 0 && A[i-1] > temp; i-- )
17 A[i] = A[i-1]; //依次与已排序序列中元素比较并右移
18 A[i] = temp;
19 }
20 }
21
22 /* 快速排序 */
23 ElementType Median3( ElementType A[], int Left, int Right )
24 {
25 int Center = (Left+Right) / 2;
26 if ( A[Left] > A[Center] )
27 Swap( &A[Left], &A[Center] );
28 if ( A[Left] > A[Right] )
29 Swap( &A[Left], &A[Right] );
30 if ( A[Center] > A[Right] )
31 Swap( &A[Center], &A[Right] );
32 /* 此时A[Left] <= A[Center] <= A[Right] */
33 Swap( &A[Center], &A[Right-1] ); /* 将基准Pivot藏到右边*/
34 /* 只需要考虑A[Left+1] … A[Right-2] */
35 return A[Right-1]; /* 返回基准Pivot */
36 }
37
38 void Qsort( ElementType A[], int Left, int Right )
39 { /* 核心递归函数 */
40 int Pivot, Cutoff = 50, Low, High;//阈值的定义
41
42 if ( Cutoff <= Right-Left ) { /* 如果序列元素充分多，进入快排 */
43 Pivot = Median3( A, Left, Right ); /* 选基准 */
44 Low = Left; High = Right-1;
45 while (1) { /*将序列中比基准小的移到基准左边，大的移到右边*/
46 while ( A[++Low] < Pivot ) ;
47 while ( A[--High] > Pivot ) ;
48 if ( Low < High ) Swap( &A[Low], &A[High] );
49 else break;
50 }
51 Swap( &A[Low], &A[Right-1] ); /* 将基准换到正确的位置 */
52 Qsort( A, Left, Low-1 ); /* 递归解决左边 */
53 Qsort( A, Low+1, Right ); /* 递归解决右边 */
54 }
55 else InsertionSort( A+Left, Right-Left+1 ); /* 元素太少，用简单排序 */
56 }
57
58 void QuickSort( ElementType A[], int N )
59 { /* 统一接口 */
60 Qsort( A, 0, N-1 );
61 }
62
63 int main()
64 {
65 int a[] = {34,8,64,51,32,21};
66 QuickSort(a, 6);
67 for(int i = 0; i < 6; i++)
68 printf("%d ",a[i]);
69 return 0;
70 }
71
72 QuickSortQuickSort
2.表排序
间接排序
定义一个指针数组(下标)作为“表”（table）
如果仅要求按顺序输出，则输出：A[ table[0] ], A[ table[1] ], ……, A[ table[N-1] ]
物理排序
N个数字的排列由若干个独立的环组成
用temp记录初值 ，每次换位子修改table值，用if ( table[i] == i )判断一个环的结束
复杂度
最好情况：初始即有序
最坏情况：
有[N / 2]向下取整 个环，每个环包含2个元素
需要[N / 2]向下取整 次元素移动
T = O( m N ) ，m 是每个A元素的复制时间。
3.基数排序
桶排序：假设我们有N 个学生，他们的成绩是0到100之间的整数（于是有M = 101 个不同的成绩值）。如何在线性时间内将学生按成绩排序？
T(N, M) = O( M+N )
当M>>N时，桶排序不合算
次位优先LSB
假设我们有N = 10 个整数，每个整数的值在0到999之间（于是有M = 1000 个不同的值）。
输入序列: 64, 8, 216, 512, 27, 729, 0, 1, 343, 125
用“次位优先”（Least Significant Digit） T=O(P(N+B))
多关键字的排序
一副扑克牌是按2种关键字排序的
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 typedef int ElementType;
5
6 /* 基数排序 - 次位优先 */
7
8 /* 假设元素最多有MaxDigit个关键字，基数全是同样的Radix */
9 #define MaxDigit 4
10 #define Radix 10
11
12 /* 桶元素结点 */
13 typedef struct Node *PtrToNode;
14 struct Node {
15 int key;
16 PtrToNode next;
17 };
18
19 /* 桶头结点 */
20 struct HeadNode {
21 PtrToNode head, tail;
22 };
23 typedef struct HeadNode Bucket[Radix];
24
25 int GetDigit ( int X, int D )
26 { /* 默认次位D=1, 主位D<=MaxDigit */
27 int d, i;
28
29 for (i=1; i<=D; i++) {
30 d = X % Radix;
31 X /= Radix;
32 }
33 return d;
34 }
35
36 void LSDRadixSort( ElementType A[], int N )
37 { /* 基数排序 - 次位优先 */
38 int D, Di, i;
39 Bucket B;
40 PtrToNode tmp, p, List = NULL;
41
42 for (i=0; i<Radix; i++) /* 初始化每个桶为空链表 */
43 B[i].head = B[i].tail = NULL;
44 for (i=0; i<N; i++) { /* 将原始序列逆序存入初始链表List */
45 tmp = (PtrToNode)malloc(sizeof(struct Node));
46 tmp->key = A[i];
47 tmp->next = List;
48 List = tmp;
49 }
50 /* 下面开始排序 */
51 for (D=1; D<=MaxDigit; D++) { /* 对数据的每一位循环处理 */
52 /* 下面是分配的过程 */
53 p = List;
54 while (p) {
55 Di = GetDigit(p->key, D); /* 获得当前元素的当前位数字 */
56 /* 从List中摘除 */
57 tmp = p; p = p->next;
58 /* 插入B[Di]号桶尾 */
59 tmp->next = NULL;
60 if (B[Di].head == NULL)
61 B[Di].head = B[Di].tail = tmp;
62 else {
63 B[Di].tail->next = tmp;
64 B[Di].tail = tmp;
65 }
66 }
67 /* 下面是收集的过程 */
68 List = NULL;
69 for (Di=Radix-1; Di>=0; Di--) { /* 将每个桶的元素顺序收集入List */
70 if (B[Di].head) { /* 如果桶不为空 */
71 /* 整桶插入List表头 */
72 B[Di].tail->next = List;
73 List = B[Di].head;
74 B[Di].head = B[Di].tail = NULL; /* 清空桶 */
75 }
76 }
77 }
78 /* 将List倒入A[]并释放空间 */
79 for (i=0; i<N; i++) {
80 tmp = List;
81 List = List->next;
82 A[i] = tmp->key;
83 free(tmp);
84 }
85 }
86
87 int main()
88 {
89 int a[] = {34,8,64,51,32,21};
90 LSDRadixSort(a, 6);
91 for(int i = 0; i < 6; i++)
92 printf("%d ",a[i]);
93 return 0;
94 }LSD
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 typedef int ElementType;
5
6 /* 基数排序 - 主位优先 */
7
8 /* 假设元素最多有MaxDigit个关键字，基数全是同样的Radix */
9
10 #define MaxDigit 4
11 #define Radix 10
12
13 /* 桶元素结点 */
14 typedef struct Node *PtrToNode;
15 struct Node{
16 int key;
17 PtrToNode next;
18 };
19
20 /* 桶头结点 */
21 struct HeadNode {
22 PtrToNode head, tail;
23 };
24 typedef struct HeadNode Bucket[Radix];
25
26 int GetDigit ( int X, int D )
27 { /* 默认次位D=1, 主位D<=MaxDigit */
28 int d, i;
29
30 for (i=1; i<=D; i++) {
31 d = X%Radix;
32 X /= Radix;
33 }
34 return d;
35 }
36
37 void MSD( ElementType A[], int L, int R, int D )
38 { /* 核心递归函数: 对A[L]...A[R]的第D位数进行排序 */
39 int Di, i, j;
40 Bucket B;
41 PtrToNode tmp, p, List = NULL;
42 if (D==0) return; /* 递归终止条件 */
43
44 for (i=0; i<Radix; i++) /* 初始化每个桶为空链表 */
45 B[i].head = B[i].tail = NULL;
46 for (i=L; i<=R; i++) { /* 将原始序列逆序存入初始链表List */
47 tmp = (PtrToNode)malloc(sizeof(struct Node));
48 tmp->key = A[i];
49 tmp->next = List;
50 List = tmp;
51 }
52 /* 下面是分配的过程 */
53 p = List;
54 while (p) {
55 Di = GetDigit(p->key, D); /* 获得当前元素的当前位数字 */
56 /* 从List中摘除 */
57 tmp = p; p = p->next;
58 /* 插入B[Di]号桶 */
59 if (B[Di].head == NULL) B[Di].tail = tmp;
60 tmp->next = B[Di].head;
61 B[Di].head = tmp;
62 }
63 /* 下面是收集的过程 */
64 i = j = L; /* i, j记录当前要处理的A[]的左右端下标 */
65 for (Di=0; Di<Radix; Di++) { /* 对于每个桶 */
66 if (B[Di].head) { /* 将非空的桶整桶倒入A[], 递归排序 */
67 p = B[Di].head;
68 while (p) {
69 tmp = p;
70 p = p->next;
71 A[j++] = tmp->key;
72 free(tmp);
73 }
74 /* 递归对该桶数据排序, 位数减1 */
75 MSD(A, i, j-1, D-1);
76 i = j; /* 为下一个桶对应的A[]左端 */
77 }
78 }
79 }
80
81 void MSDRadixSort( ElementType A[], int N )
82 { /* 统一接口 */
83 MSD(A, 0, N-1, MaxDigit);
84 }
85
86 int main()
87 {
88 int a[] = {34,8,64,51,32,21};
89 MSDRadixSort(a, 6);
90 for(int i = 0; i < 6; i++)
91 printf("%d ",a[i]);
92 return 0;
93 }MSD
转载于:https://www.cnblogs.com/kuotian/p/5469341.html
数据结构学习笔记06排序 (快速排序、表排序、基数排序)相关推荐
- MySQL学习笔记06【多表查询、子查询、多表查询练习】
MySQL 文档-黑马程序员(腾讯微云):https://share.weiyun.com/RaCdIwas 1-MySQL基础.pdf.2-MySQL约束与设计.pdf.3-MySQL多表查询与事务 ...
- 数据结构学习笔记（7.查找 8.排序）
文章目录 第七章 查找 查找--基本概念 顺序查找 折半查找(二分法查找)--重要考点 分块查找 二叉排序树BST 平衡二叉树--AVL--重要考点 平衡二叉树的删除操作 红黑树--RBT 红黑树的插 ...
- 数据结构学习笔记（3-5）：树
附录:所有blog的链接 数据结构学习笔记(1):基本概念 数据结构学习笔记(2):线性结构 数据结构学习笔记(3-5):树 数据结构学习笔记(6-8):图 数据结构学习笔记(9-10):排序 数据结 ...
- MySQL学习笔记05【多表操作、三大范式、数据库的备份和还原】
MySQL 文档-黑马程序员(腾讯微云):https://share.weiyun.com/RaCdIwas 1-MySQL基础.pdf.2-MySQL约束与设计.pdf.3-MySQL多表查询与事务 ...
- MySQL学习笔记03【数据库表的CRUD操作、数据库表中记录的基本操作、客户端图形化界面工具SQLyog】
MySQL 文档-黑马程序员(腾讯微云):https://share.weiyun.com/RaCdIwas 1-MySQL基础.pdf.2-MySQL约束与设计.pdf.3-MySQL多表查询与事务 ...
- 数据结构学习笔记之快速排序（非递归）
数据结构学习笔记之快速排序(非递归) 代码如下: #include<assert.h> #include<memory.h> //快速排序(升序) void QuickSort ...
- 数据结构学习笔记（七）：哈希表（Hash Table）
目录 1 哈希表的含义与结构特点 1.1 哈希(Hash)即无序 1.2 从数组看哈希表的结构特点 2 哈希函数(Hash Function)与哈希冲突(Hash Collision) 2.1 哈希函 ...
- Hadoop学习笔记—11.MapReduce中的排序和分组
Hadoop学习笔记-11.MapReduce中的排序和分组 一.写在之前的 1.1 回顾Map阶段四大步骤 首先,我们回顾一下在MapReduce中,排序和分组在哪里被执行: 从上图中可以清楚地看出 ...
- 数据结构学习笔记——顺序表的基本操作（超详细最终版+++）建议反复看看ヾ(≧▽≦*)o
目录 前言 一.顺序表的定义 二.顺序表的初始化 三.顺序表的建立 四.顺序表的输出 五.顺序表的逆序输出 六.顺序表的插入操作 七.顺序表的删除操作 八.顺序表的按位和按值查找 基本操作的完整代码 ...
- 数据结构学习笔记（王道）
数据结构学习笔记(王道) PS:本文章部分内容参考自王道考研数据结构笔记 文章目录 数据结构学习笔记(王道) 一.绪论 1.1. 数据结构 1.2. 算法 1.2.1. 算法的基本概念 1.2.2. ...
最新文章
- DLL: 一种直接法的激光雷达定位方案
- MyEclipse 9.x Professional/blue/spring/bling 下载与破解
- Pat乙级1089 狼人杀-简单版
- 修改IIS默认的30M
- 以Settings.APPLICATION_DEVELOPMENT_SETTINGS打开开发者面板出错总结
- Qt 中pro文件换行注意的问题
- 如何批量转化成jpg格式_heic图片格式快速转换jpg,批量转换方法
- NOI题库 7654 等差数列末项计算
- 静态类 c# 1615139615
- go 的时间与时间戳计算
- 动态注册广播接收者,屏幕锁定Android
- 传奇世界凤凰登陆器格式说明
- uniapp内使用 mescroll
- MQL5 编程基础：列表
- java设计模式之解释器模式
- 怎么将静图变动图？用这个网站就够了
- 支付宝（蚂蚁）开放平台压力测试经验
- 计算机技术与软件专业技术资格（水平）考试—— 软考中级 网络工程师笔记six
- RK3399驱动开发 | 04 - WK2124串口芯片驱动浅析
- 浏览器首页被劫持(解决）-桔梗网