数据结构学习笔记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 QuickSort

QuickSort

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

时间： 2024-07-31 13:32:26

数据结构学习笔记06排序 (快速排序、表排序)

数据结构学习笔记06排序 (快速排序、表排序)的相关文章

数据结构学习笔记06排序 (冒泡、插入、希尔)

【Java数据结构学习笔记之一】线性表的存储结构及其代码实现

数据结构学习笔记——线性表的应用

小猪的数据结构学习笔记(二)

小猪的数据结构学习笔记(四)

小猪的数据结构学习笔记(五)

数据结构学习笔记之栈

数据结构学习笔记（1）-数据结构与算法

小猪的数据结构学习笔记(三)