头歌-十大经典排序算法
第1关：冒泡排序
任务描述
本关任务：实现冒泡排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.冒泡排序算法。
冒泡排序算法
冒泡排序重复地遍历待排序的数列，每次比较两个相邻元素，如果它们的顺序错误就把它们交换。重复地进行遍历直到没有再需要交换时表示数列已经排序完成。
- 算法步骤：
- 比较相邻的元素：若第一个比第二个大，则交换；
- 遍历开始第一对到结尾最后一对，执行步骤
1； - 重复步骤
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
#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; iarr[j+1])
{//前>后 大的数后移
int temp =arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
if(i<3)
print_array(arr, n); //前三次输出
}
print_array(arr, n);
/********** End **********/
}
第2关：选择排序
任务描述
本关任务：实现选择排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.选择排序算法。
选择排序算法
选择排序是一种简单直观的排序算法，首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
- 算法步骤：
-
初始状态：无序序列为R[0,n−1]，长度n，有序区为空；
-
第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的新无序区；
-
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
#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; iarr[j])
{
min = arr[j];//如果出现更小的值，保存更小值的下标
flag = 1;//标记，找到更小的了，需要更新最小值
temp=j;//保存下标
}
if(flag==1)//"flag==1"说明找到更小的值,即下标发生了变化 -> 交换
{
int t = arr[i];
arr[i] = arr[temp];
arr[temp] = t;
flag = 0 ;//恢复标志位
}
if(i<3){
print_array(arr, n); //前三次输出
}
}
print_array(arr, n);
/********** End **********/
} 第3关：插入排序
任务描述
本关任务：实现插入排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.插入排序算法。
插入排序算法
插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
- 算法步骤：
-
从第一个元素开始，该元素认为已经被排序；
-
取下一个元素，在已经排序的元素序列中从后向前扫描；
-
如果已排序元素大于新元素，将已排序元素移到下一位置；
-
重复步骤
3，直到找到已排序的元素小于或者等于新元素的位置； -
将新元素插入到该位置后；
-
重复步骤
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
#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第4关：希尔排序
任务描述
本关任务：实现希尔排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.希尔排序算法。
希尔排序算法
希尔排序由Shell在1959年发明，又叫缩小增量排序，是第一个突破O(n2)的排序算法，属于简单插入排序的改进版，会优先比较距离较远的元素。
- 算法步骤：
-
选择一个增量序列T1，T2，… ，Tk，其中Ti>Tj，Tk=1，i>j；
-
每趟排序，根据对应的增量Ti，将待排序列分割成若干子序列，分别对各子序列进行直接插入排序；
-
按增量序列个数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
#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 0)
{
for (i = gap; i < n; i++)
{
key = arr[i];
end = i - gap;
while (end >= 0 && key 第5关：归并排序
任务描述
本关任务：实现归并排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.归并排序算法。
归并排序算法
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，是采用分治法Divide and Conquer的一个非常典型的应用。分Divide：将问题分成一些小的问题然后递归求解；治Conquer：将分的阶段得到的各答案合并在一起。
- 算法步骤：
-
把长度为n的输入序列分成两个长度为n/2的子序列；
-
对这两个子序列分别采用归并排序；
-
将两个排序好的子序列合并成一个最终的排序序列。
编程要求
本关的编程任务是补全右侧代码片段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
#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第6关：快速排序
任务描述
本关任务：实现快速排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.快速排序算法。
快速排序算法
快速排序是最常用的一种排序算法，它的特点是速度快、效率高。快速排序的基本思想：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素作为基准值。
- 算法步骤：
-
从数列中挑出一个元素，称为
基准pivot； -
分区
partition操作：比基准值小的元素放在左边，比基准值大的元素放在右边； -
递归
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
#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=temp)//"大"数在高位不动
r--;//注解①
arr[l] = arr[r];//"小"数在高位移动
while((l 第7关：堆排序
任务描述
本关任务：实现堆排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.堆排序算法。
堆排序算法
堆排序Heapsort是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
- 算法步骤：
-
将初始待排序关键字序列
(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区； -
将堆顶元素
R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn)，且满足R[1,2…n-1]<=R[n]； -
由于交换后新的堆顶
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
#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; iarr[max]&&s1arr[max]&&s2=0;i--)
{
adjustHeap(arr,n,i); //从最后一个父结点开始做最大堆调整
}
for(int i=n-1;i>=0;i--)//依次将最大堆的根结点（最大值）取出
{
//将最大堆的根（最大值）换到最后
temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
//除去最大值,对交换后的二叉树做最大堆调整，使二叉树根结点始终为最大值
adjustHeap(arr,i,0);
}
return arr;
/********** End **********/
}
第8关：计数排序
任务描述
本关任务：实现计数排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.计数排序算法。
计数排序算法
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
- 算法步骤：
-
找出待排序的数组中最大和最小的元素；
-
统计数组中每个值为
i的元素出现的次数，存入数组C的第i项； -
对所有的计数累加（从
C中的第一个元素开始，每一项和前一项相加）； -
反向填充目标数组：将每个元素
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
#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=MAX)
MAX = arr[i];
if(arr[i]<=MIN)
MIN = arr[i];
}
//生成统计数组,并清空数据
int Arr_2[MAX] ;
int j=0;
while(j<=MAX)
{
Arr_2[j] =0;
j++;
}
for( i=0;i 第9关：桶排序
任务描述
本关任务：实现桶排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.桶排序算法。
桶排序算法
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
- 算法步骤：
-
设置一个定量的数组当作空桶；
-
遍历输入数据，并且把数据一个一个放到对应的桶里去；
-
对每个不是空的桶进行排序；
-
从不是空的桶里把排好序的数据拼接起来。
编程要求
本关的编程任务是补全右侧代码片段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
#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=MAX)
MAX = arr[i];
else if(arr[i]<=MIN)
MIN = arr[i];
int len =15;//单个桶的长度
int bucketArry [Num][len];
//清空桶
for(i=0;ibucketArry[temp][j+1])
{
f = bucketArry[temp][j];
bucketArry[temp][j] = bucketArry[temp][j+1];
bucketArry[temp][j+1] = f;
}
}
}
}
int t=0,k=0;
//数据整合
for(i=0;i 第10关：基数排序
任务描述
本关任务：实现基数排序算法，并将乱序数列变成升序。
相关知识
为了完成本关任务，你需要掌握：1.基数排序算法。
基数排序算法
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
- 算法步骤：
-
取得数组中的最大数，并取得位数；
-
arr为原始数组，从最低位开始取每个位组成radix数组； -
对
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
#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=MAX)
MAX = arr[i];
if(arr[i]<=MIN)
MIN = arr[i];
}
//生成统计数组,并清空数据
int Arr_2[MAX] ;
int j=0;
while(j<=MAX)
{
Arr_2[j] =0;
j++;
}
for( i=0;i