第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
上答案:
//
// 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 flag=0;
for(int i=0;i<n-1;i++)
{
for(int j=0;j<n-i-1;j++)
{
if(arr[j]>arr[j+1])
{
int temp;
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
flag++;
if(flag<=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
上答案:
//
// 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 *********/
for (int i = 0; i < n - 1; i++) {
int min_idx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
int temp = arr[i];
arr[i] = arr[min_idx];
arr[min_idx] = temp;
if (i < 3) {
print_array(arr, n);
}
}
print_array(arr, n);
}
第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
上答案:
//
// 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 flag=0;
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
while(j>0&&arr[j]<arr[j-1])
{
int temp=arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
j--;
}
flag++;
if(flag<=3)
{
print_array(arr,n);
}
break;
}
}
print_array(arr,n);
/********** End **********/
}
第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<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 gaps[]={5,2,1};
for(int num=0;num<3;num++)
{
int gap=gaps[num];
for(int i=gap;i<n;i++)
{
int temp=arr[i];
int j=i;
while(j>=gap&&arr[j-gap]>temp)
{
arr[j]=arr[j-gap];
j-=gap;
}
arr[j]=temp;
}
print_array(arr,n);
}
print_array(arr,n);
/********** End **********/
}
第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<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* ar = new int[n1 + n2]; // Dynamically allocate memory for the array
int i = 0, j = 0, k = 0;
while (i < n1 && j < n2) {
if (arr1[i] <= arr2[j])
ar[k++] = arr1[i++];
else
ar[k++] = arr2[j++];
}
while (i < n1)
ar[k++] = arr1[i++];
while (j < n2)
ar[k++] = arr2[j++];
return ar;
}
/********** End **********/
int* merge_sort(int *arr, int n)
// 基于merge_array函数编程实现归并排序:自上而下的递归方法
// 函数参数:有序数组arr 数组arr长度
// 函数返回值:返回从小到大排序后的数组
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
int num = n / 2;
if (n <= 1) {
return arr;
}
int* left = merge_sort(arr, num);
int* right = merge_sort(arr + num, n - num);
return merge_array(left, num, right, n - num);
/********** End **********/
}
第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
上答案:
//
// 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 pivot=arr[r];//选择最后一个元素作为基准
int i=l-1;//i指向小于基准的元素的最后一个位置
for (int j = l; j < r; j++) {
if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i+1];
arr[i+1] = arr[r];
arr[r] = temp;
return i+1;
/********** End **********/
}
int* quick_sort(int *arr, int l, int r)
// 基于partition_array函数编程实现快速排序:自上而下的递归方法
// 函数参数:有序数组arr 初始l=0,r=n-1
// 函数返回值:返回从小到大排序后的数组
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
if(l<r)
{
int pivot_index=partition_array(arr,l,r);
quick_sort(arr, l, pivot_index - 1);
quick_sort(arr, pivot_index + 1, r);
}
return arr;
/********** End **********/
}