排序算法性能分析

1. 实验预习报告

一、实验内容

实验内容为常见的八大排序，分别为插入排序、希尔排序、选择排序、堆排序、快速排序、归并排序、基数排序和桶排序。

二、排序的基本原理

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序，若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。

三、实验的算法思想

1.选择排序：每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，依次排列，直到所有元素排完为止。

2.插入排序：每一次将一个待排序的数据，插入到已经排好序的有序序列中去，直到插完所有元素，整个数据排列就有序了。

3.冒泡排序：对相邻的元素进行两两比较，如果不是递增则进行交换，这样每一趟会将最大的元素“浮”到顶端，最终达到完全有序。

4.快速排序：选择一个基准元素，比基准元素小的放基准元素的前面，比基准元素大的放基准元素的后面，这种动作叫分区，每次分区都把一个数列分成了两部分，每次分区都使得一个数字有序，然后将基准元素前面部分和后面部分继续分区，一直分区直到分区的区间中只有一个元素的时候，就完成了整个的排序。

5.堆排序：将待排序序列构造成一个大根堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。

6.基数排序：基数排序的主要思想：将待排序列从低位开始排序，放入对应桶中，得到第一次子序列，再把这个子序列根据十位放入桶中，再得到子序列，以此循环，直至排完最高位，即得到最终的排序序列。

7.桶排序：原理是将所有序列分到有限数量的桶子里，每个桶子再排序，最后得到有序序列。

8.归并排序：利用二叉树思想，该算法采用经典的分治（divide-and-conquer）策略。将两个或两个以上的有序子表合并成一个新的有序表。初始时，把含有n个结点的待排序序列看作由n个长度都为1的有序子表所组成，将它们依次两两归并得到长度为2的若干有序子表，再对它们两两合并，直到得到长度为n的有序表为止，排序结束。

四、算法的性能分析

常见的冒泡排序稳定，但是速度较慢，每次只能移动相邻的两个数据。每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法(很多书都说选择排序是不稳定的，但是，完全可以将其实现成稳定的排序方法)。插入排序是已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]至a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]至b[m]用相同方法插入。

五、预习小结
    简单的冒泡排序是两层循环，相邻交换；而选择排序是未排序和排序两分，从未排序序列中寻找最小的元素，放在排序序列末尾；插入排序类似斗地主摸牌思维，把一个元素插入到有序序列合适位置；归并排序，分治思想第一弹，先将序列切分，再在合并过程排序；快速排序，分治思想第二弹，基准数分区序列，小的放左边，大的放右边；堆排序为选择排序plus，建立大顶堆，堆顶元素（最大值）插入序列末尾，再让新的元素上浮。而桶排序是空间换时间第二弹，将原数组的元素分到若干个桶，每个桶单独排序，再把桶里元素拼起来；基数排序是空间换时间第三弹，桶排序plus，根据数位，把元素分桶，然后按每个位数比较。

相比于Reader与Designer，我与Designer一起研究了在解题过程中细节，在Designer的帮助下，我纠正了一些不恰当的构想，对本次实验的题目有了更全面、更细致的理解。实验后我再次加深了对于排序思想的熟悉，并总结了遇到的问题。

实验1 排序算法性能分析实验

1. 实验目的

1.能够运用高级程序设计技术实现八大排序及其关键算法。

2.能够通过对比分析的方法分析排序等关键算法性能的影响规律。

3.掌握不同排序算法时间效率的经验分析方法，验证理论分析与经验分析的一致性。

1. 可行性分析

该实验主要针对排序算法，故初始的排序序列对排序算法的影响较大，对实验方法的设计应从初始序列的构造进行分析。

1.人为构造序列

通过固定初始的序列，人为的对序列进行调整的改良，能够在写的种类上做出较为多样的变化，可以根据算法的特性具体构造出合适的序列，以此满足排序算法对初始序列特性的需求。

2.使用已有的序列集合

通过网上搜集和资源查询找到合适的序列集合库，对于这种序列集合能够产生出不同种类的序列，可以详细划分序列的种类，且数量庞大，能够更好的对排序算法进行测试。

3.程序构造序列

通过编写代码，可以产生规模较大，数量繁多且种类不一的代码，以此满足在对排序算法进行性能测试时的分析需求，拥有足够多的测试样本来保证分析结果的可信度和准确性。

根据以上三种实验方案的设计思路，在该次试验中选用第三种实验方案。人为构造代码速度较慢且数据规模无法过大，网上收集序列集合则较为困难且使用不便，对对应集合的操作也不能及时的掌握。所以采用第三种方案，可以调和数据规模与数据种类，能够实现较为合适的序列构造，且使用方便快捷。

1. 方案设计

一、所需知识点

1.选择排序：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。重复上述过程直至所有元素均排序完毕。时间复杂度O（n^2）,空间复杂度O（1），不稳定。

2.插入排序：每步将一个待排序的记录按其排序码值的大小，插到前面已经排好的文件中的适当位置，直到全部插入完为止。时间复杂度： 最坏情况下 O(n^2）即数据为逆序情况，最好情况下 O（n）,平均情况下 O(n^2），空间复杂度：O（1）；稳定性：稳定；特点是： 数据越有序排序越快。

3.冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。时间复杂度为O（n^2），空间复杂度为O（1），特点是稳定。

4.快速排序：采用了一种分治的策略，将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。时间复杂度最好为O（n）,最差为O（n^2）,空间复杂度为O（log n），特点是不稳定。

5.堆排序：堆排序是一种树形选择排序，是对直接选择排序的有效改进。它通过建立初始堆和不断地重建堆，逐个地将排序关键字按顺序输出，从而达到排序的目的。时间复杂度为O（n^log n），空间复杂度为O（1），特点是不稳定。

6.基数排序：从低位到高位依次对待排序的关键码进行分配和收集，经过d趟分配和收集，就可以得到一个有序序列。时间复杂度为O（n*k），空间复杂度为O（n+k），特点是稳定。

7.桶排序：原理是将所有序列分到有限数量的桶子里，每个桶子再排序，最后得到有序序列。时间复杂度为O（n+k），空间复杂度为O（n+k），特点是稳定。

8.归并排序：将两个或两个以上的有序子表合并成一个新的有序表。初始时，把含有n个结点的待排序序列看作由n个长度都为1的有序子表所组成，将它们依次两两归并得到长度为2的若干有序子表，再对它们两两合并，直到得到长度为n的有序表为止，排序结束。时间复杂度为O（n^log n)，空间复杂度为O（n），特点是稳定。

二、数学模型

采用随机模型，通过改模型产生一定的基础序列，能够通过排序算法进行实际的操作和时间对比，能够深刻理解排序的定义和各种排序方法的特点，并能灵活运用。

三、详细方法

首先针对数据规模进行变化，通过增长数据规模来测试排序的时间效率，由小至大的将规模进行扩大，将排序所用时间进行统计和记录，再经过相对应的数据规模范围进行制图，根据图标的信息能够对比和分析各排序算法的性能，可通过大量重复实验精确数据。

其次对数据的类型进行针对性选择，对各排序算法所解决问题的有适合劣势进行测试，对排序算法的最优性能和最坏性能进行验证，这属于排序算法自身之间的对比，通过实验验证可以更好的理解和分析各排序算法的性能。再以生成的各种序列为基础，进行排序算法的测试与性能统计，达到分析和理解八大排序算法的基本思想和性能属性。

1. 代码设计与开发

Description给n个数字排序(n<=1000)

Input Format第一行输入一个整数n,第二行输入n个数字

Output Format输出排序候的n个数字

测试方案1：输入5

5 4 3 1 2

测试方案2：输入7

1 6 2 9 0 4 5

测试方案3：输入8

1 4 2 5 3 7 6 8

1.选择排序

代码：

#include<stdio.h>

#include<stdlib.h>

void selectSort( int *data ,int n )

{

 int i,j;

 int min = 0;

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

 {

    min = i;

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

    {

    if(data[min]>data[j])

    {   min = j;}

    }

int temp = data[min];

    data[min] = data[i];

    data[i] = temp;

 }

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

 {

  printf("%d ",data[i]);

 }

}

int main()

{

int *data,n;

scanf("%d",&n);

data=(int*)malloc(n*sizeof(int));

for(int i=0;i<n;i++)

{

scanf("%d",&(*(data+i)));

}

selectSort(data,n);

return 0;

}

2.插入排序

代码：

#include<stdio.h>

#include<stdlib.h>

void insert_sort(int *data,int n)

{

    int i,j,temp;

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

    {

        temp=data[i];

        for(j=i-1;j>=0 && temp<data[j];j--)

        {

            data[j+1]=data[j];

        }

        data[j+1]=temp;

    }

}

int main()

{

    int *data,n;

    int i,j,temp;

scanf("%d",&n);

data=(int*)malloc(n*sizeof(int));

for(int i=0;i<n;i++)

scanf("%d",&data[i]);

insert_sort(data,n);

    for(int i=0;i<n;i++)

printf("%d ",data[i]);

return 0;

}

3.冒泡排序

代码：

#include<iostream>

using namespace std;

int main()

{

int c[1000],n=0;

while(cin>>n)   

{

for(int i=0;i<n;i++)

{

cin>>c[i];

}

for(int j=0;j<n;j++)  

{

for(int k=0;k<n-j-1;k++)

{

if(c[k]>c[k+1])

{

int temp=c[k];

c[k]=c[k+1];

c[k+1]=temp;

}

}

}

for(int p=0;p<n;p++)

cout<<c[p]<<' ';

}

return 0;

}

4.快速排序

代码：

#include<iostream>

using namespace std;

const int N=300000;

int q[N];

void quick_sort(int q[],int l,int r)

{

int x,i,j;

x=q[l];i=l-1;j=r+1;

if(l==r) return;

while(i<j)

{

do i++;while(q[i]<x);

do j--;while(q[j]>x);

if(i<j) swap(q[i],q[j]);

}

quick_sort(q,l,j);

quick_sort(q,j+1,r);

}

int main()

{

int n;

scanf("%d",&n);

for(int i=0;i<n;i++)

scanf("%d",&q[i]);

quick_sort(q,0,n-1);

for(int i=0;i<n;i++)

printf("%d ",q[i]);

return 0;

}

5.堆排序

代码：

#include<stdio.h>

void HeadAdjust(int A[], int k, int len)

{

A[0] = A[k];

for (int i = 2 * k; i <= len; i = i * 2) {

if (i < len && A[i] < A[i + 1])

i++;

if (A[0] >= A[i])

break;

else

{

A[k] = A[i];

k = i;

}

}

A[k] = A[0];

}

void BuildMaxHeap(int A[], int len)

{

for (int i = len / 2; i > 0; i--)

HeadAdjust(A, i, len);

}

void HeapSort(int A[], int len)

{

BuildMaxHeap(A, len);

for (int i = len; i > 1; i--)

{

int temp;

temp = A[i];

A[i] = A[1];

A[1] = temp;

HeadAdjust(A, 1, i - 1);

}

}

int main()

{

int A[300000],n;

scanf("%d", &n);

for (int i = 1; i <= n; i++)

{

scanf("%d", &A[i]);

}

HeapSort(A, n);

for(int i=1;i<=n;i++)

{

printf("%d ",A[i]);

}

return 0;

}

6.基数排序

代码：

#include <stdio.h>

#include <malloc.h>

int get(int x,int d)  //得到位数上的数字 

{

int b[9]={1,10,100,1000,10000,100000,1000000,10000000,10000000}; 

    return ((x/b[d-1])%10);

}

void pai(int *a,int **r,int *num)

{

int i,m=0;

int b[10]={0};

for(i=0;i<=9;)

{

while(b[i]<num[i]&&num[i]!=0)

    {

a[m++]=r[i][b[i]];

        b[i]++;

   }

   i++; 

}

}

void radixsort(int *a,int n)

{

int **r,*num,d,i,j,k;

r=(int**)malloc(sizeof(int*)*10);  

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

r[i]=(int*)malloc(sizeof(int)*n);  

num=(int*)malloc(sizeof(int)*10);

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

{

num[i]=0;

}

for(d=1;d<=9;d++) //最大值为32767，为5位数，比较5轮 

{

for(k=0;k<n;k++)

{

j=get(a[k],d);

r[j][num[j]]=a[k];

num[j]++;

}

pai(a,r,num); 

for(i=0;i<10;i++)//num数组计算0~9每个队列中有的数，每轮后要置0 

num[i]=0;

}

for(i=0;i<n;i++)//输出结果 

printf("%d ",a[i]);

}

int main()

{

int n,i,x;

int *a;

scanf("%d",&n);

a=(int*)malloc(sizeof(int)*n);

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

scanf("%d",&a[i]);

radixsort(a,n);

return 0;

}

7.桶排序

代码：

#include<iostream>

using namespace std;

int a[300001];

int main()

{

int i,j,n,x;

cin>>n;

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

  a[i]=0;

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

{

cin>>x;

a[x]++;

}

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

{

for(j=1;j<=a[i];j++)

  cout<<i<<" "; 

}

return 0;

}

8.归并排序

代码：

#include <iostream>

using namespace std;

const int N = 3*1e6+ 30;

int n, q[N], tmp[N];

void merge_sort(int q[], int l, int r)

{

if(l >= r) return;

int mid = l + r >> 1;

merge_sort(q, l, mid), merge_sort(q, mid + 1, r);

    

int k = 0,i = l,j=mid+1;

while(i <= mid && j <= r)

if(q[i] <= q[j]) tmp[k ++] = q[i ++];

else tmp[k ++] = q[j ++];     

while(i <= mid) tmp[k ++] = q[i ++];

while(j <= r) tmp[k ++] = q[j ++];

for(i=l,j=0; i <= r; i ++,j ++) q[i]=tmp[j];}

int main()

{

scanf("%d", &n);

for(int i=0; i<n; i++) scanf("%d", &q[i]); 

merge_sort(q, 0, n-1);

for(int i=0; i<n;i++) printf("%d ", q[i]);

return 0;

}

1. 实验结果展示

1. 终身学习

阅读专业书籍，文献，课堂上认真听讲，观看学习网课。

看的书不要局限于课本，要多涉略，通过购买一些专业方向的书或图书馆借阅，经典的专业书籍一定要细细研读，一般读3遍。

文献阅读，能出现在书上的知识大都是陈旧的，只有最新的文献才能了解所关注的领域的前沿，这就需要首先了解感兴趣的方向，然后学会文献检索。

网课有慕课（MOOC）、和腾讯课堂，慕课是免费的大学生学习平台，里面授课的教师是各大高校的优秀教师，涉及的内容也非常的丰富，而且每节课的时间都很短（一般在10分钟左右），可以合理利用你的时间碎片，收获知识。

个人喜欢北京大学屈婉玲教授的《算法分析与设计》课程，老师授课的思维非常灵活、思路也非常清晰，但是难度较高，需要不断地反复学习来掌握。