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

最新推荐文章于 2024-05-12 15:31:47 发布
最新推荐文章于 2024-05-12 15:31:47 发布
阅读量2.5k 收藏 46
点赞数 31
分类专栏： 数据结构（C语言） 文章标签： 排序算法 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76435948/article/details/135316348
版权

文章目录

第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(n2)的排序算法，属于简单插入排序的改进版，会优先比较距离较远的元素。

算法步骤：

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

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

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

希尔排序实例：

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

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

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

编程要求

本关的编程任务是补全右侧代码片段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 **********/
}

在这里插入图片描述

剑心诀
关注
  • 31
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
十大经典排序算法
牵LV小猪精的博客
05-05 1万+
十大经典排序算法 根据算法的时间空间复杂度列出以下10种排序算法，其中蓝色底的为稳定排序，绿色底的为不稳定排序。 先谈一谈稳定性：稳定性简单来讲就是考虑排序后值相同的元素和排序前是否保持一致（如排序前a1和a2值相同，排序后仍是a1在前a2在后） 注：希尔排序时间复杂度在O(nlogn)~O(n2）之间 根据时间复杂度来划分成三小类排序 1.时间复杂度为O(n2) 1.1.冒泡排序（Bubble Sort） 简单的思想：数组中相邻元素两两比较[以左边大为例子，交换两者的位置]；每一次.
数据结构排序——直接插入排序算法的实现
溪中鲤信笺的博客
08-21 1002
直接插入排序 1. 基本思想 直接插入插排的基本思想是：当插入第i(i >=1)时，前面的V[0]，V[1]，……，V[i-1]已经排好序。这时，用V[I]的排序码与V[i-1]，V[i-2]，…的排序码顺序进行比较，找到插入位置即将V[i]插入，原来位置上的元素向后顺移。 在图中给出了直接插入排序的过程。设在元素表中有n =6个元素，为了使描述书简介直观，在图中只画出各元素的排序码。其中有两个排序码相同，前一个直接写为25，后一个标记为25*。假定其中V[0]，…，V[i-1]已经是一组有序的元素
头歌 插入类排序
lmq886的博客
06-15 1443
【代码】头歌 插入类排序。
十大经典排序算法【算法思想+图解+代码】【数据结构与算法笔记】
魚肉的博客
01-22 5829
排序算法还不懂？十大经典排序算法详解。【算法思想+图解+代码】冒泡排序，插入排序，选择排序，快速排序……看完你绝对能手撕各种排序算法。
头歌C语言数据结构课程实验（顺序表及其应用）
最新发布
zzj的博客
05-12 940
定义如下：#define MAXSIZE 100 //最大长度// 数据元素的类型//指向数据元素的起始地址int length;//线性表的当前长度}SqList;
头歌数据结构实训参考---十大经典排序算法
m0_73938966的博客
08-22 3359
【代码】头歌数据结构实训参考---十大经典排序算法。
Educoder头歌数据结构-十大经典排序算法
热门推荐
qq_50848214的博客
12-06 2万+
数据结构-十大经典排序算法 "不定时更新中" "还未写完，但可全部通关" "仅供参考" 第1关：冒泡排序 void sort_array(int *arr, int n) // 编程实现《冒泡排序算法》：将乱序序列arr转化为升序序列 // 函数参数：乱序整数数组arr 数组长度 // 要求输出：调用print_array(int *arr, int n)输出前三次冒泡操作后的序列，以及最终的升序序列 { // 请在这里补充代码，完成本关任务 /********** Begin **
数据结构-十大经典排序算法之希尔排序
CSU_hjh的博客
05-18 1349
数据结构-十大经典算法之希尔排序 算法思想 算法步骤 算法动态演示 部分代码实现 第一部分：算法思想 希尔排序由Shell在1959年发明，又叫缩小增量排序，是第一个突破O(n^2)的排序算法，属于简单插入排序的改进版，会优先比较距离较远的元素。 第二部分：算法步骤 选择一个增量序列；每趟排序，根据对应的增量，将待排序列分割成若干子序列，分别对各子序列进行直接插入排序；按增量序列个数，对序列进行趟排序。 第三部分：算法动态演示 下图的增量序列为：5，2，1，第一趟排序将增量为5的子序列进行插入排序，第二
数据结构-十大经典排序算法之插入排序
CSU_hjh的博客
05-17 728
数据结构-十大经典排序算法之插入排序 算法思想 算法步骤 算法动态演示 部分代码实现 第一部分：算法思想 插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 第二部分：算法步骤 从第一个元素开始，该元素认为已经被排序； 取下一个元素，在已经排序的元素序列中从后向前扫描； 如果已排序元素大于新元素，将已排序元素移到下一位置； 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置； 将新元素插入到该位置后； 重复步骤2~5。 第三部分:算法动态演示
Java练习算法代码(排序，数据结构，小算法练习题).zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
《数据结构与算法》期末练习题(含答案).pdf
12-30
本文档提供了《数据结构与算法》期末练习题的答案，涵盖了数据结构与算法的基础知识，包括算法的计算量、时间复杂度、存储结构、链式存储、顺序存储、双向链表、排序算法、栈和递归算法等。 1．算法的计算量的大小...
十大经典排序算法，附带动画演示效果，超硬核
12-30
《十大经典排序算法》是一部深入浅出的教程，旨在帮助计算机专业的学生更好地理解数据结构与算法。本教程涵盖了十大经典排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数...
数据结构和算法练习题.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
数据结构之排序--插入类排序
year_9的专栏
11-17 978
一. 插入类排序 1. 直接插入排序 2. 二分插入排序 3.希尔排序     希尔排序优于直接插入排序。理由：1> 当待排数列大致有序时，比较和移动的次数较少（比较后才移动，比较的少自然移动的少，移动的少比较的也少）        2> 当待排数列元数个数较少时，n 与 n^2 的差距也小。即O(n)与O(n^2)差不多        3>希尔排序刚开始时，增量大，分组多，之后增量减
educode平台一维数组和二维数组实验第三题
ManmX的博客
05-31 5669
任务描述 题目描述:按如下函数原型编程从键盘输入一个m行n列的二维数组，然后计算数组中元素的最大值及其所在的行列下标值。其中m和n的值由用户键盘输入。已知m和n的值都不超过10。 相关知识（略） 输入 输入数组大小："%d,%d" 下面输入数组中元素。 输出 输出格式： 数组大小输入提示信息："Input m, n:" 数组元素输入提示信息："Input %d*%d array: " 输出格式："max=%d, row=%d, col=%d" 样例输入 5,5 1 2 3 4 5 4 5
Java数据结构之排序(头歌平台，详细注释)
qwertf123的博客
01-18 1860
Java数据结构之排序
数据结构与算法篇--插入排序
程麒阁的博客
07-26 130
插入排序 插入排序的核心思想是，从前到后找排序元素，然后出坑；然后从后到前找插入位置，入坑。如果是升序排序的话，如果当前项的数值大于排序元素，那么就让当前数值向后移动，反之则请排序元素直接进入空隙 核心思想 从前到后找待排序元素，从后到前找插入位置。每次都在更新，每次都在迭代知道全部结束。每一次都在排小的，然后越来越大，前到后，步步都是基础，后面依赖前面。 C语言实现 插入排序 #include<stdio.h> int* InsertSort(int*arr,int size) { for
十大经典的排序算法
qq_46796338的博客
06-03 262
排序算法是《数据结构与算法》中最基本的算法之一，下面价绍了七种排序方式，分别是插入排序、希尔排序、选择排序、冒泡排序、归并排序等，附加源代码 1.冒泡排序 算法步骤： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较 C源代码： #include<stdio.h> //按升序排序
数据结构和算法练习题
09-07
数据结构和算法练习题是一种用来巩固和提升对数据结构和算法的理解和应用能力的练习题集合。它们涵盖了多个主题，包括汉诺塔、回溯、二进制、二叉树、BST(二叉搜索树)、分而治之、动态规划、图表、堆、链表、矩阵、队列、排序、细绳、特里、贪婪的拼图等。这些练习题的目的是帮助学习者通过实践来巩固理论知识，并提供机会来锻炼编程和问题解决能力。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

剑心诀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值