实验九 排序算法的实现（插入排序、快速排序、选择排序、归并排序）直接插入排序、希尔排序，冒泡排序、快速排序，简单选择排序、堆排序，递归和非递归形式的归并排序

1. 实验目的

熟悉排序的方法、过程及原则。掌握插入排序、快速排序、选择排序、归并排序的算法思想及实现方法，掌握其时间复杂度的分析方法。

1. 实验内容

定义待排序序列的存储结构。验证插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序中各排序方法中的一、二个排序算法。

1. 插入类排序：直接插入排序、希尔排序
2. 交换类排序：冒泡排序、快速排序
3. 选择类排序：简单选择排序、堆排序

4. 归并类排序：递归和非递归形式的归并排序

1. 问题描述

排序的算法有很多种，复杂度也各不相同，在数据量很少的情况下，很难区分它们的优劣，但对大量数据进行分析时，不同的算法所花费的时间和空间就相差很多了。一般数据处理工作 25%的时间都在进行排序。通过对排序算法做对比研究，能在编写程序的时候运用适当的排序方法，这样就可以显著提高数据处理的效率。

稳定性，时间复杂度和空间复杂度分析

使用6种排序算法分别对随机生成的五组数据进行排序，给每种算法添加相应的标志来直观感受每种算法的优劣情况，该系统需要实现以下功能：

1. 编写排序算法：直接插入排序、冒泡排序、希尔排序、快速排序、二分插入排序;
2. 生成100个随机数，作为测试样本

1. 数据结构定义

使用顺序表的数据结构进行内部排序操作

1. 算法思想及算法设计

  插入排序---直接插入排序（Straight  lnsertion  Sort）

基本思想：

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

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

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

直接插入排序示例：

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

时效分析：

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

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

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想：

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

操作方法：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

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

每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

希尔排序的示例：

算法的实现：

我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

时效分析：

希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列d的选取，特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法，有取奇数的，也有取质数的，但需要注意：增量因子中除1 外没有公因子，且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

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

基本思想：

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

简单选择排序的示例：

操作方法：

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

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

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

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

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

冒泡排序的示例：

 

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

基本思想：

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

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

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

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

快速排序的示例：

一趟排序的过程：

排序的全过程：

时效分析：

 快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

归并排序（Merge Sort）

基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序示例：

算法的实现：

1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。

1. 实验代码

   

 void Inserte_sort(int A[], int n)//返回循环比较次数

{

int i, j, temp,a=0,aa=0;

for (i = 1, a++; i < n; i++, a++)

if (A[i] < A[i - 1])

{

temp = A[i];

for (a++, aa++, j = i - 1; j >= 0 && A[j] > temp; j--, a++, aa++)

A[j + 1] = A[j];

A[j + 1] = temp;

}



}

void Select_sort(int A[], int n)//以A[0]为比较依据 升序  

{

int i, j, k,a=0,aa=0;

for (i = 0, a++; i < n - 1; i++, a++)

{

k = i;

for (j = i + 1, a++; j < n; j++, a++)

if (A[j] < A[k])

{

k = j; a++;

}

if (k != i)

{

aa += Change_a_b(&A[i], &A[k]);

}

}



}

void Bubble_sort(int A[], int n)

{

int i, j, a=0;

long long aa=0;

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

{

for (j = 0; j < i; j++)

{

if (A[j] > A[j + 1])

aa += Change_a_b(&A[j], &A[j + 1]);

}

}

a = (n - 1) * n/ 2;



}

void Quick_sort(int A[], int L, int R)//快速排序 升序   

{

int i = L, j = R, T = A[L]; //T为基准数  

if (L > R)  return;

while (i != j) //当数组左右两边没相遇  

{

while (A[j] >= T && i < j) { j--;c++; }  //从右向左找

while (A[i] <= T && i < j) { i++; c++; } //从左向右找   

if (i < j)cc += Change_a_b(&A[i], &A[j]); //交换两数  

}

if (L != i)

cc += Change_a_b(&A[L], &A[i]);       //基准数归位  

Quick_sort(A, L, i - 1);         //递归左  

Quick_sort(A, i + 1, R);         //递归右  

}

void Shell_sort(int A[], int n)//希尔排序 增量为2

{

int i, j, k,a=0,aa=0;

for (k = n >> 1, a++; k > 0; k = k >> 1, a++)

{

for (i = k, a++; i < n; i++, a++)

{

for (j = i - k, a++; j >= 0; j -= k, a++)

if (A[j] > A[j + k])

aa += Change_a_b(&A[j], &A[j + k]);

}

}



}

int Merge(int S[], int L, int M, int R, int T[])//数组归并操作  

{

int i = M, j = R, k = 0, count = 0;

while (i >= L && j > M)

{

b++;

if (S[i] > S[j])

{

T[k++] = S[i--];//从临时数组的最后一个位置开始排序  



}

else  T[k++] = S[j--];

count++;

}



while (i >= L) { b++; T[k++] = S[i--]; } //若前半段数组还有元素未放入临时数组T中  

while (j > M) { b++; T[k++] = S[j--]; }

for (i = 0, b += k; i < k; i++)  S[R - i] = T[i];//写回原数组

return count;

}

void Merging_sort(int S[], int L, int R, int T[])

{

int M;

if (L < R)

{

M = (L + R) >> 1;

Merging_sort(S, L, M, T);//找左半段的逆序对数目  

Merging_sort(S, M + 1, R, T);//找右半段的逆序对数目  

bb += Merge(S, L, M, R, T);//找完左右半段逆序对以后两段数组有序，找两段之间的逆序对。  

}

}

1. 算法测试

排序：查看排序结果:

1. 分析与总结

   1.排序稳定，所谓排序稳定就是指：如果两个数相同，对他们进行的排序结果为他们的相对顺序不变。例如A={1,2,1,2,1}这里排序之后是A = {1,1,1,2,2} 稳定就是排序后第一个1就是排序前的第一个1，第二个1就是排序前第二个1，第三个1就是排序前的第三个1。同理2也是一样。这里用颜色标明了。不稳定呢就是他们的顺序不应和开始顺序一致。也就是可能会是A={1,1,1,2,2}这样的结果。

2.感觉谁最好，在我的印象中快速排序是最好的，时间复杂度：n*log(n)，不稳定排序。原地排序。他的名字很棒，快速嘛。当然快了。我觉得他的思想很不错，分治，而且还是原地排序，省去和很多的空间浪费。速度也是很快的，n*log(n)。但是有一个软肋就是如果已经是排好的情况下时间复杂度就是n*n,不过在加入随机的情况下这种情况也得以好转，而且他可以做任意的比较，只要你能给出两个元素的大小关系就可以了。适用范围广，速度快。

3.插入排序：n*n的时间复杂度，稳定排序，原地排序。插入排序是我学的第一个排序，速度还是很快的，特别是在数组已排好了之后，用它的思想来插入一个数据，效率是很高的。因为不用全部排。他的数据交换也很少，只是数据后移，然后放入要插入的数据。（这里不是指调用插入排序，而是用它的思想）。我觉得，在数据大部分都排好了，用插入排序会给你带来很大的方便。数据的移动和交换都很少。

4.冒泡排序，n*n的时间复杂度，稳定排序，原地排序。冒泡排序的思想很不错，一个一个比较，把小的上移，依次确定当前最小元素。因为他简单，稳定排序，而且好实现，所以用处也是比较多的。还有一点就是加上哨兵之后他可以提前退出。

5.选择排序，n*n的时间复杂度， 稳定排序，原地排序。选择排序就是冒泡的基本思想，从小的定位，一个一个选择，直到选择结束。他和插入排序是一个相反的过程，插入是确定一个元素的位置，而选择是确定这个位置的元素。他的好处就是每次只选择确定的元素，不会对很多数据进行交换。所以在数据交换量上应该比冒泡小。

6.插入排序，选择排序，冒泡排序的比较，他们的时间复杂度都是n*n。我觉得他们的效率也是差不多的，我个人喜欢冒泡一些，因为要用它的时候数据多半不多，而且可以提前的返回已经排序好的数组。而其他两个排序就算已经排好了，他也要做全部的扫描。在数据的交换上，冒泡的确比他们都多。举例说明插入一个数据在末尾后排序，冒泡只要一次就能搞定，而选择和插入都必须要n*n的复杂度才能搞定。

7.合并排序：n*log(n)的时间复杂度， 稳定排序，非原地排序。他的思想是分治，先分成小的部分，排好部分之后合并，因为我们另外申请的空间，在合并的时候效率是0(n)的。速度很快。貌似他的上限是n*log(n)，所以如果说是比较的次数的话，他比快速排序要少一些。对任意的数组都能有效地在n*log(n)排好序。但是因为他是非原地排序，所以虽然他很快，但是貌似他的人气没有快速排序高。

8.堆排序：n*log(n)的时间复杂度， 非稳定排序，原地排序。他的思想是利用的堆这种数据结构，堆可以看成一个完全二叉树，所以在排序中比较的次数可以做到很少。加上他也是原地排序，不需要申请额外的空间，效率也不错。可是他的思想感觉比快速难掌握一些。还有就是在已经排好序的基础上添加一个数据再排序，他的交换次数和比较次数一点都不会减少。虽然堆排序在使用的中没有快速排序广泛，但是他的数据结构和思想真的很不错，而且用它来实现优先队列，效率没得说。堆，还是要好好学习掌握的。

9.希尔排序：n*log(n)的时间复杂度(这里是错误的，应该是n^lamda(1 < lamda < 2), lamda和每次步长选择有关。)， 非稳定排序，原地排序。主要思想是分治，不过他的分治和合并排序的分治不一样，他是按步长来分组的，而不是想合并那样左一半右一半。开始步长为整个的长度的一半。分成nLen/2个组，然后每组排序。接个步长减为原来的一半在分组排序，直到步长为1，排序之后希尔排序就完成了。这个思路很好，据说是插入排序的升级版，所以在实现每组排序的时候我故意用了插入排序。我觉得他是一个特别好的排序方法了。他的缺点就是两个数可能比较多次，因为两个数据会多次分不过他们不会出现数据的交换。效率也是很高的。

10.快速排序，堆排序，合并排序，希尔排序的比较，他们的时间复杂的都是n*log(n)，我认为在使用上快速排序最广泛，他原地排序，虽然不稳定，可是很多情况下排序根本就不在意他是否稳定。他的比较次数是比较小的，因为他把数据分成了大和小的两部分。每次都确定了一个数的位置，所以理论上说不会出现两个数比较两次的情况，也是在最后在交换数据，说以数据交换上也很少。合并排序和堆排序也有这些优点，但是合并排序要申请额外的空间。堆排序堆已经排好的数据交换上比快速多。所以目前快速排序用的要广泛的多。还有他很容易掌握和实现。

11.基数排序：n的时间复杂度，稳定排序，非原地排序。他的思想是数据比较集中在一个范围，例如都是4位数，都是5位数，或数据有多个关键字，我们先从各位开始排，然后排十位，依次排到最高位，因为我们可以用一个n的方法排一位，所以总的方法为d*n的复杂度。关键字也一样，我们先排第3个关键字，在排第3个关键字，最后排第一个关键字。只有能保证每个关键字在n的时间复杂度完成，那么整个排序就是一个d*n的时间复杂度。所以总的速度是很快的。不过有一点就是要确保关键字能在n的时间复杂度完成。

    （2）实验总结

        排序算法的最后感悟：黑格尔说过：存在即合理。所以这些排序的算法都是很好的，他确实给了我们思想上的帮助。感谢前人把精华留给了我们。我得到的收获很大，总结一下各自排序的收获：
冒泡：好实现，速度不慢，使用于轻量级的数据排序。
插入排序：也使用于小数据的排序，但是我从他的思想中学到怎么插入一个数据。呵呵，这样就知道在排好的数据里面，不用再排序了，而是直接调用一下插入就可以了。
选择排序：我学会了怎么去获得最大值，最小值等方法。只要选择一下，不就可以了。
合并排序：我学会分而治之的方法，而且在合并两个数组的时候很适用。