数据结构--排序算法介绍

数据结构--排序算法总结

概述

排序的分类：内部排序和外部排序

内部排序：数据记录在内存中进行排序

外部排序：因排序的数据量大，需要内存和外存结合使用进行排序

这里总结的八大排序是属于内部排序：

当n比较大的时候，应采用时间复杂度为（nlog2n）的排序算法：快速排序、堆排序或归并排序。

其中，快速排序是目前基于比较的内部排序中被认为最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。

———————————————————————————————————————————————————————————————————————

插入排序——直接插入排序（Straight Insertion Sort）

基本思想：

将一个记录插入到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。

即：先将序列的第1个记录看成一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，用于临时存储和判断数组边界

直接插入排序示例：

插入排序是稳定的，因为如果一个带插入的元素和已插入元素相等，那么待插入元素将放在相等元素的后边，所以，相等元素的前后顺序没有改变。

算法实现：

[cpp]view plain copy

1.#include

https://www.360docs.net/doc/8917363877.html,ing namespace std;

3.

4.void print(int a[], int n ,int i)

5.{

6. cout<

7.for(int j= 0; j<8; j++){

8. cout<

9. }

10. cout<

11.}

12.

13.void InsertSort(int a[],int n)

14.{

15.int i,j,tmp;

16.for(i=1;i

17. {

18.// 如果第i个元素大于第i-1个元素，直接插入

19.// 否则

20.// 小于的话，移动有序表后插入

21.if(a[i]

22. {

23. j=i-1;

24. tmp=a[i]; // 复制哨兵，即存储待排序元素

25. a[i]=a[i-1]; // 先后移一个元素

26.while(tmp

27. {

28.// 哨兵元素比插入点元素小，后移一个元素

29. a[j+1]=a[j];

30. --j;

31. }

32. a[j+1]=tmp; // 插入到正确的位置

33. }

34. print(a,n,i); // 打印每一趟排序的结果

35. }

36.}

37.

38.int main()

39.{

40.int a[8]={3,1,5,7,3,4,8,2};

41. print(a,8,0); // 打印原始序列

42. InsertSort(a,8);

43.return 0;

44.}

分析：

时间复杂度：O（n^2）

———————————————————————————————————————————————————————————————————————

插入排序——希尔排序（Shell Sort）

基本思想：

先将整个待排序的记录序列分割成为若干子序列，分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录依次进行直接插入排序。

操作方法：

1.选择一个增量序列{ t1，t2，t3，...，tk }

2.按增量序列个数k，对序列进行k趟排序；

3.每趟排序，根据对应的增量ti，将待排序序列分割成若干长度为m的子序列，分别对各子

序列进行直接插入排序。仅增量因为为1时，整个序列作为一个整表来处理，表长度即

为整个序列的长度。

希尔排序的示例：

算法实现：

**如何选择增量序列？

简单选择：增量序列d = { n/2，n/4，n/8，...，1 } ，其中n为要排序数的个数。[cpp]view plain copy

1.#include

https://www.360docs.net/doc/8917363877.html,ing namespace std;

3.

4.void print(int a[], int n)

5.{

6.for(int j= 0; j<8; j++){

7. cout<

8. }

9. cout<

10.}

12.void ShellInsertSort(int a[],int n,int dk)

13.{

14.int i,j,tmp;

15.for(i=dk;i

16. {

17.// 如果第i个元素大于第i-dk个元素，直接插入

18.// 否则

19.// 小于的话，移动有序表后插入

20.if(a[i]

21. {

22. j=i-dk;

23. tmp=a[i];

24. a[i]=a[i-dk]; // 复制哨兵，即存储待排序元素

25.while(tmp

26. {

27.// 哨兵元素比插入点元素小，后移dk个元素

28. a[j+dk]=a[j];

29. j-=dk;

30. }

31. a[j+dk]=tmp; // 插入到正确的位置

32. }

33. }

34.}

35.

36.void ShellSort(int a[],int n)

37.{

38.int dk=n/2;

39.while(dk>=1)

40. {

41. ShellInsertSort(a,n,dk);

42. dk/=2;

43. }

44.}

46.int main()

47.{

48.int a[8]={3,1,5,7,3,4,8,2};

49. print(a,8); // 打印原始序列

50. ShellSort(a,8);

51. print(a,8); // 打印排序后的序列

52.return 0;

53.}

分析：

可以发现，希尔排序是对简单插入排序算法的一种改进。

但希尔排序是不稳定的排序方法，因为排序过程中可能会改变相同元素在原始序列中的前后关系。

关于希尔排序的时效分析，取决于增量因子序列d的选取，特定情况下可以估算出关键码的比较次数和记录的移动次数。

目前还没有人给出选取最好的增量因子序列的方法。

———————————————————————————————————————————————————————————————————————

选择排序——简单选择排序（Simple Selection Sort）

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数进行交换；然后在剩下的数当中再找最小（或者最大）的数与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n 个元素（最后一个数）比较为止。

简单选择排序示例：

操作方法：

第一趟：从n个记录中找出关键码最小的记录与第一个记录交换；

第二趟：从第2个记录开始的n-1个记录中再选出关键码最小的记录与第2个记录交换；

以此类推...

第i 趟：从第i个记录开始的n-i+1个记录中选出关键码最小的记录与第i个记录交换，直至整个序列按关键码有序。

算法实现：

[cpp]view plain copy

1.#include

https://www.360docs.net/doc/8917363877.html,ing namespace std;

3.

4.void print(int a[], int n ,int i)

5.{

6. cout<<"第"<

7.for(int j= 0; j<8; j++){

8. cout<

9. }

10. cout<

11.}

12.

13.// 返回数组的最小值的键值

14.int SelectMinKey(int a[],int n,int i)

15.{

16.int k=i;

17.for(int j=i+1;j

18.if(a[k]>a[j])

19. k=j;

20.return k;

21.}

22.

23.void SelectSort(int a[],int n)

24.{

25.int key,tmp;

26.for(int i=0;i

27. {

28. key=SelectMinKey(a,n,i); // 选择最小的元素

29.if(key!=i)

30. {

31.// 最小元素与第i位置元素互换

32. tmp=a[i];

33. a[i]=a[key];

34. a[key]=tmp;

35. }

36. print(a,n,i);

37. }

38.}

39.

40.int main()

41.{

42.int a[8]={3,1,5,7,3,4,8,2};

43. cout<<"原始序列：";

44.for(int i=0;i<8;++i)

45. {

46. cout<

47.if(i==7)

48. cout<

49.else

50. cout<<" ";

51. }

52. SelectSort(a,8);

53.return 0;

54.}

———————————————————————————————————————————————————————————————————————

选择排序——堆排序（Heap Sort）

基本思想：

1）初始化堆；将数列[ 1 ... n ]构造成最大化堆

2）交换数据：将a[ 1 ]和a[ n ]交换，使a[ n ]是[ 1 ... n ]中的最大值；然后将[ 1 ... n-1 ]重新调整为最大堆。接着，将a[ 1 ]和a[ n-1 ]交换，使a[ n-1 ]是[ 1 ... n-1 ]中的最大值；然后将[ 1 ... n-2 ]重新调整为最大堆。依次类推，直到整个数列有序。

堆排序的示例：

实现中用到了“数组实现的二叉堆的性质”。

在第一个元素的索引为0的情形中：

性质一：索引为i 的左孩子的索引是（2*i+1）；

性质二：索引为i 的右孩子的索引是（2*i+2）；

性质三：索引为i 的父节点的索引是floor( ( i-1 ) / 2 )；

下面演示对a={20,30,90,40,70,110,60,10,100,50,80}, n=11进行堆排序过程

数组a对应的初始结构：

1 初始化堆：

在堆排序算法中，首先要将待排序的数组转换成最大堆。

下面演示将数组{20,30,90,40,70,110,60,10,100,50,80}转换为最大堆{110,100,90,40,80,20,60,10,30,50,70}的步骤。

1.1 i = n/2 - 1，即i = 4

1.2 i = 3

1.3 i = 2

1.4 i = 1

1.5 i = 0

2 交换数据

在将数组转换成最大堆后，接着要进行交换数据，从而使数组成为一个真正的有序数组。

下面是当n = 10时交换数组的示意图：

当n = 10时，首先交换a[0]和a[10]，使得a[10]是a[0 ... 10 ]之间的最大值；然后调整a[0 ... 9 ]使它成为最大堆。交换之后，a[10]是有序的；

当n = 9时，首先交换a[0]和a[9]，使得a[9]是a[0 ... 9 ]之间的最大值；然后调整a[0 ... 8 ]使它成为最大堆。交换之后，a[9]是有序的；

... ...

依次类推，直到a[0 ... 10 ]是有序的。

算法实现：

[cpp]view plain copy

1.#include

https://www.360docs.net/doc/8917363877.html,ing namespace std;

3.

4.void maxheap_down(int a[],int start,int end)

5.{

6.int current=start; // 当前结点的位置

7.int left=2*current+1; // 左孩子的位置

8.int tmp=a[current]; // 当前节点的大小

9.for(;left<=end;current=left,left=2*left+1)

10. {

11.if(left

12. ++left; // 左右孩子中选择较大者

13.if(tmp>=a[left])

14.break; //调整结束

15.else

16. {

17.// 交换值

18. a[current]=a[left];

19. a[left]=tmp;

20. }

21. }

22.}

23.

24.void HeapSort(int a[],int n)

25.{

26.int i,tmp;

27.// 从(n/2-1) --> 0逐次遍历。遍历之后，得到的数组实际上是一个(最大)二叉堆。

28.for(i=n/2-1;i>=0;--i)

29. maxheap_down(a,i,n-1);

30.// 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素

31.for(i=n-1;i>0;--i)

32. {

33.// 交换a[0]和a[i]。交换后，a[i]是a[0...i]中最大的

34. tmp=a[i];

35. a[i]=a[0];

36. a[0]=tmp;

37.// 调整a[0...i-1]，使得a[0...i-1]仍然是一个最大堆;

38.// 即，保证a[i-1]是a[0...i-1]中的最大值

39. maxheap_down(a,0,i-1);

40. }

41.}

42.

43.int main()

44.{

45.int i;

46.int a[]={20,30,90,3,21,11,60,10,23,50,80};

47.int len=(sizeof(a))/(sizeof(a[0]));

48. cout<<"原始序列：";

49.for(i=0;i

50. cout<

51. cout<

52. HeapSort(a,len);

53. cout<<"堆排序后的序列：";

54.for(i=0;i

55. cout<

56. cout<

57.return 0;

58.}

分析：

时间复杂度：O（nlog2n）

遍历一趟的时间复杂度是O（n）；

堆排序是采用二叉堆进行排序的，二叉堆就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的定义，它的深度至少是log2(n+1)，最多也不会超过log22n。因此，遍历次数介于log2(n+1)和log22n之间；因此得出它的时间复杂度是O（nlog2n）。

堆排序稳定性：不稳定的

它在交换数据的时候，是比较父节点和子节点之间的数据，所以即使是存在两个数值相等的兄弟结点，它们的相对顺序在排序中也可能发生变化。

———————————————————————————————————————————————————————————————————————

交换排序——冒泡排序（Bubble Sort）

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的数往上冒。

即：每当相邻的数比较后发现它们的顺序与排序要求相反时，就将它们互换。

冒泡排序的示例：

算法实现：

[cpp]view plain copy

1.#include

https://www.360docs.net/doc/8917363877.html,ing namespace std;

3.

4.void print(int a[], int n ,int i)

5.{

6. cout<<"第"<

7.for(int j= 0; j<8; j++){

8. cout<

9. }

10. cout<

11.}

12.

13.void BubbleSort(int r[],int size)

14.{

15.int i,j,temp;

16.bool exchange; //交换标志

17.for(i=0;i

18. {

19. exchange=false; //本趟排序开始前，交换标志设为假

20.for(j=size-1;j>=i;--j)

21.if(r[j]

22. {

23. temp=r[j]; //暂存单元

24. r[j]=r[j-1];

25. r[j-1]=temp;

26. exchange=true; //发生了交换，故将交换标志置为真

27. }

28.if(!exchange) //本趟没有发生交换，提前终止算法

29.return;

30. print(r,size,i);

31. }

32.}

33.

34.int main()

35.{

36.int r[8]={3,1,5,7,3,4,8,2};

37. cout<<"原始序列：";

38.for(int i=0;i<8;i++)

39. {

40. cout<

41.if(i==7)

42. cout<

43.else

44. cout<<" ";

45. }

46. BubbleSort(r,8);

47.return 0;

48.}

———————————————————————————————————————————————————————————————————————

交换排序——快速排序（Quick Sort）

基本思想：

1）选择一个基准元素，通常选择第一个元素或者最后一个元素

2）通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小，另一部分记录的元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序

快速排序的示例：

a）一趟排序的过程：

b）排序的全过程：

算法实现：

[cpp]view plain copy

1.#include

https://www.360docs.net/doc/8917363877.html,ing namespace std;

3.

4.int Partition(int r[],int first,int end)

5.{

6.int i=first,j=end,temp; //初始化

7.while(i

8. {

9.//j从后向前扫描，直到r[j]

值相比）的记录移动到前面去；

10.while(i

11.if(i

12. {

13.//将较小记录交换到前面

14. temp=r[i];

15. r[i]=r[j];

16. r[j]=temp;

17. ++i;

18. }

19.//i从前向后扫描，直到r[i]>r[j]，将r[i]移动到r[j]的位置，使关键码大（同轴

值相比）的记录移动到后面去；

20.while(i

21.if(i

22. {

23.//将较大记录交换到后面

24. temp=r[i];

25. r[i]=r[j];

26. r[j]=temp;

27. --j;

28. }

29.//重复上述过程，直到i=j

30. }

31.return i;

32.}

33.

34.void QuickSort(int r[],int first,int end)

35.{

36.if(https://www.360docs.net/doc/8917363877.html,rst

37. {