十大排序算法

冒泡排序算法

冒泡排序重复地遍历待排序的数列，每次比较两个相邻元素，如果它们的顺序错误就把它们交换。重复地进行遍历直到没有再需要交换时表示数列已经排序完成。

• 算法步骤：

  1. 比较相邻的元素：若第一个比第二个大，则交换；

  2. 遍历开始第一对到结尾最后一对，执行步骤1；

  3. 重复步骤1~2，直到排序完成。

• 可改进的冒泡排序：第一趟排序之后最后一个元素是最大的，因此下一趟遍历只需执行到倒数第二对。

主要代码：

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}
void sort_array(int *arr, int n)
//  编程实现《冒泡排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组arr 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次冒泡操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    for (int i=0; i<n; i++) {
        for (int j=0; j<n-1-i; j++) {
            if(arr[j]>arr[j+1]){
                swap(arr[j], arr[j+1]);
            }
        }
        if (i<3) {
            print_array(arr, n);
        }
    }
    print_array(arr, n);
    /********** End **********/
}

选择排序算法

选择排序是一种简单直观的排序算法，首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

• 算法步骤：

  1. 初始状态：无序序列为R[0,n−1]，长度n，有序区为空；

  2. 第i=1,..,n−1趟排序从当前无序区R[i−1,n−1]中选出最小的元素R[k]，并将它与无序区的第1个记录R[i−1]交换，则R[0,i−1]变为元素个数增加1的新有序区，R[i,n−1]变为元素个数减少1的新无序区；

  3. n−1趟选择交换后结束。

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}
void sort_array(int *arr, int n)
//  编程实现《选择排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组（无重复元素） 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次选择操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    for (int i=0; i<n-1; i++) {
        int minIdx = i;
        for (int j=i+1; j<n; j++) {
            if(arr[minIdx]>arr[j]){
                minIdx = j;
            }
        }
        swap(arr[i], arr[minIdx]);
        // 交换arr[i]和arr[minIdx]
        if (i<3) {
            print_array(arr, n);
        }
    }
    print_array(arr, n);
    /********** End **********/
}

插入排序算法

插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

• 算法步骤：

  1. 从第一个元素开始，该元素认为已经被排序；

  2. 取下一个元素，在已经排序的元素序列中从后向前扫描；

  3. 如果已排序元素大于新元素，将已排序元素移到下一位置；

  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

  5. 将新元素插入到该位置后；

  6. 重复步骤2~5。

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}
void sort_array(int *arr, int n)
//  编程实现《插入排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组（无重复元素） 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次插入操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    for (int i=1; i<n; i++) {
        int val = arr[i];
        for (int j=i-1; j>=0; j--) {
            if(val<arr[j]){
                arr[j+1] = arr[j];
                arr[j] = val;
            }else{
                break;
            }
        }
        if(i<=3){
            print_array(arr, n);
        }
    }
    print_array(arr, n);
    /********** End **********/
}

希尔排序算法

希尔排序由Shell在1959年发明，又叫缩小增量排序，是第一个突破O(n2)的排序算法，属于简单插入排序的改进版，会优先比较距离较远的元素。

• 算法步骤：

  1. 选择一个增量序列T1​，T2​，… ，Tk​，其中Ti​>Tj​，Tk​=1，i>j；

  2. 每趟排序，根据对应的增量Ti​，将待排序列分割成若干子序列，分别对各子序列进行直接插入排序；

  3. 按增量序列个数k，对序列进行k趟排序。

• 希尔排序实例： 下图的增量序列为：5，2，1，第一趟排序将增量为5的子序列进行插入排序，第二趟排序将增量为2的子序列进行插入排序，第三趟将增量为1的子序列进行插入排序，最终完成排序。

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

void sort_array(int *arr, int n)
//  编程实现《希尔排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组 数组长度
//  要求输出：调用print_array(int *arr, int n)输出三遍增量排序操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int c=0,e,f=10;
    for(int a=f/2;a>0;a=a/2)
    {
        for(int i=a;i<n;i++)
    {
        for(int d=i-a;d<n;d=d+a)
        if(arr[i-a]>arr[d])
        {
            e=arr[d];
            arr[d]=arr[i-a];
            arr[i-a]=e;
        }
        
      
    }
      c++;
        if(c<=3)
         print_array(arr,  n);
    }
    print_array(arr,  n);
    /********** End **********/
}

归并排序算法

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，是采用分治法Divide and Conquer的一个非常典型的应用。分Divide：将问题分成一些小的问题然后递归求解；治Conquer：将分的阶段得到的各答案合并在一起。

• 算法步骤：

  1. 把长度为n的输入序列分成两个长度为n/2的子序列；

  2. 对这两个子序列分别采用归并排序；

  3. 将两个排序好的子序列合并成一个最终的排序序列。

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}
int* merge_array(int *arr1, int n1, int* arr2, int n2)
//  编程实现两个有序数组arr1和arr2合并
//  函数参数：有序数组arr1 数组arr1长度 有序数组arr2 数组arr2长度
//  函数返回值：返回从小到大排序后的合并数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int* arr = (int*)malloc(sizeof(int)*(n1+n2));
    int p = 0;
    int p1 = 0;
    int p2 = 0;
    while (p1<n1 || p2<n2) {
        if(p1<n1 && p2<n2){
            // 自上而下的递归方法使得这两个数组各自是有序的
            // 选择两个数组较小的给arr
            if (arr1[p1]<arr2[p2]) {
                arr[p++] = arr1[p1++];
            }else{
                arr[p++] = arr2[p2++];
            }
        }else if(p1<n1){
            // arr2排完了，余下arr1
            arr[p++] = arr1[p1++];
        }else if(p2<n2){
            // arr1排完了，余下arr2
            arr[p++] = arr2[p2++];
        }
    }
    return arr;
    /********** End **********/
}
int* merge_sort(int *arr, int n)
//  基于merge_array函数编程实现归并排序：自上而下的递归方法
//  函数参数：有序数组arr 数组arr长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(n==1){
        return arr;
    }
    int m = n/2;
    int* arr1 = (int*)malloc(sizeof(int)*(m));
    int* arr2 = (int*)malloc(sizeof(int)*(n-m));
    for (int i=0, j=0; i<m; i++, j++) {
        // 左半边数组给arr1
        arr1[j] = arr[i];
    }
    for (int i=m, j=0; i<n; i++, j++) {
        // 右半边数组给arr2
        arr2[j] = arr[i];
    }
    // 递归子数组
    arr1 = merge_sort(arr1, m);
    arr2 = merge_sort(arr2, n-m);
    // 合并子数组
    return merge_array(arr1, m, arr2, n-m);
    /********** End **********/
}

快速排序算法

快速排序是最常用的一种排序算法，它的特点是速度快、效率高。快速排序的基本思想：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素作为基准值。

• 算法步骤：

  1. 从数列中挑出一个元素，称为基准pivot；

  2. 分区partition操作：比基准值小的元素放在左边，比基准值大的元素放在右边；

  3. 递归recursive：把小于基准值元素的子数列和大于基准值元素的子数列分别递归排序。

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

int partition_array(int *arr ,int l,int r)
// 编程实现arr[l, r]分区：选定一个基准，左边比基准小，右边比基准大
// 返回基准所处位置
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int m=arr[l];
    while(r!=l)
    {
        for(r;r!=l;r--)
        if(arr[r]<m)
        {
            arr[l]=arr[r];
            break;
        }
        for(l;l!=r;l++)
        if(arr[l]>m)
        {
            arr[r]=arr[l];
            break;
        }
    }
    arr[l]=m;
return l;
    /********** End **********/
}

int* quick_sort(int *arr, int l, int r)
//  基于partition_array函数编程实现快速排序：自上而下的递归方法
//  函数参数：有序数组arr 初始l=0，r=n-1
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(l<r)
    {
    int p=partition_array(arr,l,r);
    quick_sort(arr,l,p-1);
    quick_sort(arr,p+1,r);
    }
    return arr;
    /********** End **********/
}

堆排序算法

堆排序Heapsort是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

• 算法步骤：

  1. 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；

  2. 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn)，且满足R[1,2…n-1]<=R[n]；

  3. 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

void adjustHeap(int *arr, int param1, int j)
// 编程实现堆的调整
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int temp = arr[param1];

for(int i = 2*param1 +1;i<= j;i = 2*i+1)          //i是左孩子下标

{

	//判断是否有右孩子

	if(i < j && arr[i] < arr[i+1])                 //说明有右孩子,左孩子小于右孩子

	{

		i++;

	}

	if(arr[i] > temp)

	{

		arr[param1] = arr[i];

		param1 = i;

	}

	else

	{

		break;

	}

}

arr[param1] = temp;

计数排序算法

计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

• 算法步骤：

  1. 找出待排序的数组中最大和最小的元素；

  2. 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；

  3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；

  4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}
void sort_array(int *arr, int n)
//  编程实现《计数排序算法》
//  函数参数：乱序整数数组 数组长度
//  要求输出：调用print_array(int *arr, int n)输出：
//  每一行一个元素及其个数（升序），如 1 1
//  以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
        // 数组最大值
    int maxVal = arr[0];
    for (int i=1; i<n; i++) {
        if(maxVal<arr[i]){
            maxVal = arr[i];
        }
    }
    // 申请计数数组，并初始化为0
    int* cnt = (int*)malloc(sizeof(int)*(maxVal+1));
    for (int i=0; i<=maxVal; i++) {
        cnt[i] = 0;
    }
    // 对arr数组元素计数
    for (int i=0; i<n; i++) {
        cnt[arr[i]]++;
    }
    // 顺序输出计数结果
    for (int i=0, k=0; i<=maxVal; i++){
        if (cnt[i]) {
            printf("%d %d\n", i, cnt[i]);
        }
        for (int j=0; j<cnt[i]; j++) {
            arr[k++] = i;
        }
    }
    print_array(arr, n);
    /********** End **********/
}

桶排序算法

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

• 算法步骤：

  1. 设置一个定量的数组当作空桶；

  2. 遍历输入数据，并且把数据一个一个放到对应的桶里去；

  3. 对每个不是空的桶进行排序；

  4. 从不是空的桶里把排好序的数据拼接起来。

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}


int* sort_array(int *arr, int n)
//  编程实现《桶排序算法》
//  函数参数：乱序整数数组 数组长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int maxVal = arr[0];
for(int i = 1; i < n; i++)  //遍历比较，找到大的就赋值给maxVal

{

    if(arr[i] > maxVal)

        maxVal = arr[i];

}


int tmpArrLen = maxVal + 1;

int tmpArr[tmpArrLen];  //获得空桶大小

int i, j;



for( i = 0; i < tmpArrLen; i++)  //空桶初始化

    tmpArr[i] = 0;



for(i = 0; i < n; i++)   //寻访序列，并且把项目一个一个放到对应的桶子去。

    tmpArr[ arr[i] ]++;



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

{

    while( tmpArr[ i ] != 0) //对每个不是空的桶子进行排序。

    {

        arr[j ] = i;  //从不是空的桶子里把项目再放回原来的序列中。

        j++;

        tmpArr[i]--;

    }

}
return arr;


    
    /********** End **********/
}

基数排序算法

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

• 算法步骤：

  1. 取得数组中的最大数，并取得位数；

  2. arr为原始数组，从最低位开始取每个位组成radix数组；

  3. 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}


int* sort_array(int *arr, int n)
//  编程实现《基数排序算法》
//  函数参数：乱序整数数组 数组长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int temp[10][n]={0}; //第一个10表示0~9，第二个20表示a的size

int order[n]={0};    

int i,j,k; //k表示当前比较的那一位上的具体数字

int t; //n=1,10,100,1000...取决于a中的最大的数

int p;

t=1;	

while(t <= 100)

{

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

	{

		k = (arr[i]/t) % 10;

		temp[k][order[k]] = arr[i];

		order[k]++;

	}	

	p=0; //p为一次排序过程中,a的脚标

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

	{

		if(order[i] != 0)

		{

			for(j=0;j<order[i];j++)

			{

				arr[p] = temp[i][j];

				p++;

			}

		order[i] = 0;

		}

	}	

	t *= 10;

}	

    
return arr;

    
    /********** End **********/
}