【数据结构】十大经典排序算法（头歌习题）【合集】

第1关：冒泡排序

任务描述

本关任务：实现冒泡排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.冒泡排序算法。

冒泡排序算法

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

算法步骤：

1. 比较相邻的元素：若第一个比第二个大，则交换；
2. 遍历开始第一对到结尾最后一对，执行步骤1；
3. 重复步骤1~2，直到排序完成。

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

编程要求

本关的编程任务是补全右侧代码片段sort_array中Begin至End中间的代码，具体要求如下：

• 在sort_array中，实现冒泡排序算法，完成指定输出。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 4 6 7 8 5 2 3 9 10
1 4 6 7 5 2 3 8 9 10
1 4 6 5 2 3 7 8 9 10
1 2 3 4 5 6 7 8 9 10

测试输入：
15
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
预期输出：
3 38 5 44 15 36 26 27 2 46 4 19 47 48 50
3 5 38 15 36 26 27 2 44 4 19 46 47 48 50
3 5 15 36 26 27 2 38 4 19 44 46 47 48 50
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 *********/
    int temp;
    for(int i=0; i<n-1;i++){
        for(int j=0; j<n-1; j++){
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        if(i<3){
            for(int i=0; i<n; i++){
                if(i<n-1){
                    printf("%d ", arr[i]);
                }else{
                    printf("%d", arr[i]);
                }      
            }
            putchar('\n');
        }
    }
    for(int i=0; i<n; i++){
        if(i<n-1){
            printf("%d ", arr[i]);
        }else{
            printf("%d", arr[i]);
        }
    }
    
    /********** End **********/
}

第2关：选择排序

任务描述

本关任务：实现选择排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.选择排序算法。

选择排序算法

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

算法步骤：

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趟选择交换后结束。

编程要求

本关的编程任务是补全右侧代码片段sort_array中Begin至End中间的代码，具体要求如下：

• 在sort_array中，实现选择排序算法，完成指定输出。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 7 4 6 8 9 5 2 3 10
1 2 4 6 8 9 5 7 3 10
1 2 3 6 8 9 5 7 4 10
1 2 3 4 5 6 7 8 9 10

测试输入：
15
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
预期输出：
2 44 38 5 47 15 36 26 27 3 46 4 19 50 48
2 3 38 5 47 15 36 26 27 44 46 4 19 50 48
2 3 4 5 47 15 36 26 27 44 46 38 19 50 48
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 temp, min;
    for(int i=0; i<n-1; i++){
        min = i;
        for(int j=i+1; j<n; j++){    
            if(arr[j]<arr[min]){
                min = j;
            }
            
        }
        temp = arr[min];
        arr[min] = arr[i];
        arr[i] = temp;

        if(i<3){
            print_array(arr, n);
        }
    }
    print_array(arr, n);
    /********** End **********/
}

第3关：插入排序

任务描述

本关任务：实现插入排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.插入排序算法。

插入排序算法

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

算法步骤：

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

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

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

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

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

6. 重复步骤2~5。

编程要求

本关的编程任务是补全右侧代码片段sort_array中Begin至End中间的代码，具体要求如下：

• 在sort_array中，实现插入排序算法，完成指定输出。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 7 4 6 8 9 5 2 3 10
1 4 7 6 8 9 5 2 3 10
1 4 6 7 8 9 5 2 3 10
1 2 3 4 5 6 7 8 9 10

测试输入：
15
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
预期输出：
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
3 38 44 5 47 15 36 26 27 2 46 4 19 50 48
3 5 38 44 47 15 36 26 27 2 46 4 19 50 48
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 key;
    int j;
    for(int i=1; i<n; i++){
        key = arr[i];
        j = i-1;
        while(j>=0 && arr[j]>key){
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
        if(i<=3){
            print_array(arr, n);
        }
    }
    print_array(arr, n);
    
    /********** End **********/
}

第4关：希尔排序

任务描述

本关任务：实现希尔排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.希尔排序算法。

希尔排序算法

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

算法步骤：

1. 选择一个增量序列T₁ ，T₂ ，… ，T_k，其中T_i >T_j ，T_k =1，i>j；

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

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

希尔排序实例：

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

希尔排序的核心在于增量序列的设定：

既可以提前设定好增量序列，也可以动态的定义增量序列。例如序列长度为n，则动态增量为：1，4，7，…，3x+1

编程要求

本关的编程任务是补全右侧代码片段sort_array中Begin至End中间的代码，具体要求如下：

• 在sort_array中，使用增量序列[5, 2, 1]实现希尔排序算法，完成指定输出。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
8
6 10 5 2 4 9 1 7
预期输出：
6 1 5 2 4 9 10 7
4 1 5 2 6 7 10 9
1 2 4 5 6 7 9 10
1 2 4 5 6 7 9 10

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
7 1 2 3 8 9 5 4 6 10
2 1 5 3 6 4 7 9 8 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 gap[]={5, 2, 1};
    int i, j, k=0;
    int count=0;

    while(k<3){
        // 按步长插入排序
        for(i=gap[k]; i<n; i++){
            j = i;
            // 插入排序
            int temp;
            while(j>=gap[k] && arr[j-gap[k]] > arr[j]){
                temp = arr[j];
                arr[j] = arr[j-gap[k]];
                arr[j-gap[k]] = temp;
                j -= gap[k]; 
            }
        }
        // 得到新的步长
        count++;
        if(count<=3){
            print_array(arr, n);
        }
        k++;
    }
    print_array(arr, n);
    /********** End **********/
}

第5关：归并排序

任务描述

本关任务：实现归并排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.归并排序算法。

归并排序算法

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

算法步骤：

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

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

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

编程要求

本关的编程任务是补全右侧代码片段merge_array和merge_sort中Begin至End中间的代码，具体要求如下：

• 在merge_array中，实现两个有序数组arr1和arr2合并。
• 在merge_sort中，实现归并排序：自上而下的递归方法。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 2 3 4 5 6 7 8 9 10

测试输入：
15
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
预期输出：
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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((n1+n2)*sizeof(int));
    int i=0;
    int j=0;
    int k=0;

    while(i<n1 && j<n2){
        if(arr1[i]<=arr2[j]){
            arr[k] = arr1[i];
            i++;
        }else{
            arr[k] = arr2[j];
            j++;
        }
        k++;
    }
    if(i<n1){
        while(i<n1){
            arr[k] = arr1[i];
            i++;
            k++;
        }
    }else if(j<n2){
        while(j<n2){
            arr[k] = arr2[j];
            j++;
            k++;
        }
    }
    return arr;
    
    /********** End **********/
}
int* merge_sort(int *arr, int n)
//  基于merge_array函数编程实现归并排序：自上而下的递归方法
//  函数参数：有序数组arr 数组arr长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(n<2){
        return arr;
    }
    int mid = n/2;
    int *left = (int*)malloc(mid * sizeof(int));
    int *right = (int*)malloc((n-mid) * sizeof(int));

    for(int i=0; i<mid; i++){
        left[i] = arr[i];
    }
    for(int j=mid; j<n; j++){
        right[j-mid] = arr[j];
    }

    left = merge_sort(left, mid);
    right = merge_sort(right, n-mid);

    int *merged = merge_array(left, mid, right, n-mid);
    free(left);
    free(right);

    return merged;
    
    /********** End **********/
}

第6关：快速排序

任务描述

本关任务：实现快速排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.快速排序算法。

快速排序算法

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

算法步骤：

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

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

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

编程要求

本关的编程任务是补全右侧代码片段partition_array和quick_sort中Begin至End中间的代码，具体要求如下：

• 在partition_array中，实现数组分区：选定一个基准，左边比基准小，右边比基准大，返回基准所处位置。
• 在quick_sort中，实现快速排序：自上而下的递归方法。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 2 3 4 5 6 7 8 9 10

测试输入：
15
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
预期输出：
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 idx=l+1;  // 边界索引
    int x = arr[l];
    for(int i=idx; i<r+1; i++){
        if(arr[i]<=x){
            int temp = arr[i];
            arr[i] = arr[idx];
            arr[idx] = temp;
            idx++;
        }
    }
    // 将基准元素交换到中间去
    arr[l] = arr[idx-1];
    arr[idx-1] = x;
    return idx-1;

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

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

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

第7关：堆排序

任务描述

本关任务：实现堆排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.堆排序算法。

堆排序算法

堆排序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，则整个排序过程完成。
   

编程要求

本关的编程任务是补全右侧代码片段adjustHeap和heap_sort中Begin至End中间的代码，具体要求如下：

• 在adjustHeap中，实现堆的调整。
• 在heap_sort中，构建大顶堆，并调用adjustHeap实现堆的调整。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 2 3 4 5 6 7 8 9 10

测试输入：
15
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
预期输出：
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 i=param1;
    int k=2*i+1;  //计算左孩子
    while(k<=j){
        if(k<j && arr[k]<arr[k+1]){
            k++;
        }
        if(arr[i]<arr[k]){
            // 交换
            swap(arr[i], arr[k]);
            i = k;
            k = 2*i+1;
        }
        else break;
    }
    /********** End **********/
}

int* heap_sort(int *arr, int n)
//  基于adjustHeap函数编程实现堆排序
//  函数参数：无序数组arr 数组长度n
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    // 1. 构建大根堆 从最后一个分支结点开始
    for(int i=n/2 - 1; i>=0; i--){  
        adjustHeap(arr, i, n-1);
    }

    // 2. 把根节点交换到最后一个叶子节点的位置
    for(int i=n-1; i>=1; i--){
        swap(arr[0], arr[i]);
        adjustHeap(arr, 0, i-1);
    }
    return arr;
    /********** End **********/
}

第8关：计数排序

任务描述

本关任务：实现计数排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.计数排序算法。

计数排序算法

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

算法步骤：

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

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

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

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

编程要求

本关的编程任务是补全右侧代码片段sort_array中Begin至End中间的代码，具体要求如下：

• 在sort_array中，实现计数排序算法，完成指定输出。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 1
2 1
3 1
4 1
5 1
6 1
7 1
8 1
9 1
10 1
1 2 3 4 5 6 7 8 9 10

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 min = arr[0];
    int max = arr[0];
    // 找最大、最小值
    for(int i=0; i<n; i++){
        if(arr[i] < min){
            min = arr[i];
        }
        if(arr[i]>max){
            max = arr[i];
        }
    }
    
    int c_size = max + 10;
    // 计数数组
    int c[c_size];
    for(int i=min; i<=max; i++) c[i] = 0;
    // 统计每个元素出现的次数
    for(int i=0; i < n; i++){
        c[arr[i]]++;
    }

    // 输出每个元素的个数
    int k=0;
    for(int i=min; i <=max; i++){
        if(c[i] > 0){
            printf("%d %d\n", i, c[i]);
            // 反向填充排序后的目标数组
            while(c[i]>0){
                arr[k++] = i;
                c[i]--;
            }
        }
    }

    // 输出排序后的数组
    print_array(arr, n);
    
    /********** End **********/
}

第9关：桶排序

任务描述

本关任务：实现桶排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.桶排序算法。

桶排序算法

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

算法步骤：

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

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

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

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

编程要求

本关的编程任务是补全右侧代码片段sort_array中Begin至End中间的代码，具体要求如下：

• 在sort_array中，实现桶排序算法，并返回升序的数组。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 2 3 4 5 6 7 8 9 10

测试输入：
15
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
预期输出：
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 max_ = 0;
    int min_ = 0;
    for(int i=0; i<n; i++){
        max_ = (arr[i]>max_) ? arr[i] : max_;
        min_ = (arr[i]<min_) ? arr[i] : min_;
    } 
    // 桶的数量
    int bucketCount = max_ - min_ + 1;
    // 创建桶 
    int buckets[bucketCount][n];
    // 记录每个桶中的元素个数
    int counts[bucketCount] = {0};
    
    // 将元素装桶里
    for(int i=0; i<n; i++){
        // 装哪个桶
        int bucket_index = arr[i]/bucketCount;
        // 当前桶的元素索引
        int count = counts[bucket_index];
        buckets[bucket_index][count] = arr[i];
        counts[bucket_index]++;
    }

    // 对各个桶元素排序
    for(int i=0; i<bucketCount; i++){
        if(counts[i] > 0){
            qsort(buckets[i], counts[i], sizeof(int), 
                [](const void *a, const void *b) -> int { return *(int *)a - *(int *)b; });
        }
    }

    // 合并桶中的元素到原始数组
    int *result = (int *)malloc(n*sizeof(int));
    int idx=0;
    for(int i=0; i<bucketCount; i++){
        for(int j=0; j<counts[i]; j++){
            result[idx++] = buckets[i][j];
        }
    }

    return result;
    /********** End **********/
}

第10关：基数排序

任务描述

本关任务：实现基数排序算法，并将乱序数列变成升序。

相关知识

为了完成本关任务，你需要掌握：1.基数排序算法。

基数排序算法

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

算法步骤：

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

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

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

编程要求

本关的编程任务是补全右侧代码片段sort_array中Begin至End中间的代码，具体要求如下：

在sort_array中，实现基数排序算法，并返回升序的数组。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：
10
7 1 4 6 8 9 5 2 3 10
预期输出：
1 2 3 4 5 6 7 8 9 10

测试输入：
15
3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
预期输出：
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

开始你的任务吧，祝你成功！

---

完整代码

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

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 i;
    int maxvalue = arr[0];
    for(i=1; i<n; i++){
        if(arr[i] > maxvalue){
            maxvalue = arr[i];
        }
    }

    int radixCnt = 10;
    vector<int> radix[radixCnt];
    int maxDigit = 0;
    while(maxvalue){
        maxvalue /= 10;
        maxDigit++;
    }
    
    for(int i=0,dev=1; i<maxDigit; i++,dev*=10){
        for(int j=0; j<radixCnt; j++){
            radix[j].clear();
        }
        for(int j=0; j<n; j++){
            int digit=(arr[j]/dev)%10;
            radix[digit].push_back(arr[j]);
        }
        for(int j=0,t=0; j<radixCnt; j++){
            for(int k=0; k<int(radix[j].size()); k++){
                arr[t++] = radix[j][k];
            }
        }
    }
    return arr;

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