交换类排序

第1关：比较相邻两个元素求最大值

• 任务描述
• 相关知识
• 编程要求
• 测试说明

---

任务描述

本关任务：编写函数通过比较数组相邻两个元素求数组最大值。

相关知识

现在有长度为n个整型数组a，用交换法求数组中的最大值的解题思路如下： 第1步：如果 a[0]>a[1]，a[0]和a[1]交换，a[1]是a[0]、a[1]中的大者。 第2步：如果 a[1]>a[2]，a[1]和a[2]交换，a[2]是前三个数组元素中最大者。 …… 第n-1步：如果 a[n-2]>a[n-1]，a[n-2]和a[n-1]交换，a[n-1]是n个数组元素中最大者。

比较相邻的元素。如果第一个比第二个大，就交换他们两个，对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，最后的元素应该会是最大的数。

编程要求

根据提示，在右侧编辑器 Begin-End 区间补充代码，完成三个函数的定义，具体要求如下：

• 函数 input()实现一维数组的创建和输入；
• 函数 output()实现一维数组的输出；
• 函数 comp()实现求数组最大值的功能；
• 函数 swap()实现交换两个正型变量值的功能。

测试说明

平台会对你编写的代码进行测试：

测试输入： 10 39 1 4 32 91 57 6 33 2 88

输入说明： 第一行为n，表示n个整数。 第二行为n个整数。

预期输出： 1 4 32 39 57 6 33 2 88 91

输出说明： 最后一个元素应该是最大值

---

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

#include <stdio.h>
#include<stdlib.h>
void input(int *&a,int & n);
void output(int *a,int n);
void comp(int *a, int n) ;
void swap(int &a, int &b);

int main ()
{ 
	int i,n;
	int *a = NULL;	
	input (a,n);
  	comp(a, n) ;
	output(a,n);
	free(a);
	return 0;
}
/**********定义函数**********/ 
/********** Begin **********/ 
void input(int *&a,int & n)
{
	scanf("%d",&n);
	a=(int *)malloc(n*sizeof(int));
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
}
void output(int *a,int n)
{
	for(int i=0;i<n;i++)
	{
		printf("%d ",a[i]);
	}
}
void comp(int *a,int n)
{
	int t;
	for(int j=0;j<n-1;j++)
	{
		if(a[j]>a[j+1])
		{
			t=a[j];
			a[j]=a[j+1];
			a[j+1]=t;
		}
	}
}

/********** End **********/

第2关：冒泡排序

• 任务描述
• 相关知识
• 编程要求
• 测试说明

---

任务描述

本关任务：编写函数实现冒泡排序。

相关知识

为了完成本关任务，要了解冒泡法排序的算法思想：

对所有相邻记录的关键字值进行比较，如果是逆序则将其交换，最终达到有序化，其处理过程为：

1. 将整个待排序的记录序列划分成有序区和无序区，初始状态有序区为空，无序区包括所有待排序的记录。
2. 对无序区从前向后依次将相邻记录的关键字进行比较，若逆序将其交换，从而使得关键字值小的记录向上“飘浮”（左移），关键字值大的记录好像石块，向下“堕落”（右移）。 每经过一趟冒泡排序，都使无序区中关键字值最大的记录进入有序区，对于由n个记录组成的记录序列，最多经过n-1趟冒泡排序，就可以将这n个记录重新按关键字顺序排列。

以长度为n=10的序列（8 7 6 5 9 3 4 0 2 1）的冒泡排序过程做示范： 　　

第一趟：在经过9次对所有相邻数据进行比效后，则数组中元素为（7 6 5 8 3 4 0 2 1 9）； 　　第二趟：在经过8次对所有相邻数据进行比效后，则数组中元素为（6 5 7 3 4 0 2 1 8 9）； 　　第三趟：在经过7次对所有相邻数据进行比效后，则数组中元素为（5 6 3 4 0 2 1 7 8 9）； …… 以此类推，共执行9趟操作，可将有n=10个元素的数组排成有序序列（0 1 2 3 4 5 6 7 8 9）。

编程要求

平台会对你编写的代码进行测试，对数组中的元素实现冒泡排序，并输出每一次排序后的结果。具体请参见后续测试样例。

• 定义函数void Bubble_sort(int *a,int n);来实现冒泡排序的功能。

测试说明

平台会对你编写的代码进行测试：

测试输入： 10 29 62 73 90 46 43 38 76 52 93

输入说明： 第一行为n，表示n个整数。 第二行为n个整数。

预期输出： 29 62 73 90 46 43 38 76 52 93 29 62 73 46 43 38 76 52 90 93 29 62 46 43 38 73 52 76 90 93 29 46 43 38 62 52 73 76 90 93 29 43 38 46 52 62 73 76 90 93 29 38 43 46 52 62 73 76 90 93 29 38 43 46 52 62 73 76 90 93 29 38 43 46 52 62 73 76 90 93 29 38 43 46 52 62 73 76 90 93

---

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

#include <stdio.h>
#include<stdlib.h>
#include<time.h>
void input(int *&a,int & n);
void output(int *a,int n);
void comp(int *a, int n) ;
void swap(int &a, int &b);
void Bubble_sort(int *a,int n);
int main ()
{ 
	int i,n;
	int *a = NULL;	
	input (a,n);
  	Bubble_sort(a, n) ;	
	free(a);
	return 0;
}
void input(int *&a,int & n)
{
    int i;
    scanf("%d",&n);    
    if((a=(int *) malloc ((n)*sizeof(int)))==NULL)
    {
        printf("不能成功分配内存单元\n");
        exit(0);
    }
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }            
}
void output(int *a,int n)
{
    int i;
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
}
void swap(int &a, int &b)
{
    int t;
    t=a;a=b;b=t;
}

/**********定义Bubble_sort()函数**********/ 
/********** Begin **********/ 
void Bubble_sort(int *a,int n)
{
    int t;
    for(int i=0;i<n-1;i++)
    {
        for(int j=0;j<n-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
        }
        for(int k=0;k<n;k++)
        {
            printf("%d ",a[k]);
        }
        printf("\n");
    }
}

/********** End **********/

第3关：快速排序的递归算法

• 任务描述
• 相关知识
• 编程要求
• 测试说明

---

任务描述

本关任务：编写函数实现快速排序的递归算法。

相关知识

快速排序是对冒泡排序的一种改进，由C. A. R. Hoare在1960年提出。快速排序算法通过多次比较和交换来实现排序，首先对无序的记录序列进行“一次划分”，之后分别对分割所得两个子序列“递归”进行快速排序。

设要排序的数组是a[0]……a[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一次划分。

一次划分的算法思想是：

1. 设置两个变量low、high，排序开始的时候：low=0，high=N-1；以第一个数组元素作为基准，赋值给key，即key=A[low]；
2. 因为默认数组的第一个数为基准，所以从后面开始向前搜索（high--），找到第一个小于key的a[high]，就将 a[high] 赋给 a[low]，即 a[low] = a[high]。（循环条件是 a[high] >= key；结束时 a[high] < key）
3. 此时从前面开始向后搜索（low++），找到第一个大于key的a[low]，就将 a[low] 赋给 a[high]，即 a[high] = a[low]。（循环条件是 a[low]<= key ；结束时 a[low] > key）
4. 循环 2-3 步骤，直到 low=high，该位置就是基准位置。把基准数据赋给当前位置。

编程要求

根据提示，在右侧编辑器补充代码。

测试说明

平台会对你编写的代码进行测试，对数组中的元素实现快速排序，并输出每一次划分后数组元素的值，具体请参见后续测试样例。

测试输入： 10 49 82 68 71 48 27 69 23 87 17

输入说明： 第一行为n，表示n个整数。 第二行为n个整数。

预期输出： 17 23 27 48 49 71 69 68 87 82 17 23 27 48 49 71 69 68 87 82 17 23 27 48 49 71 69 68 87 82 17 23 27 48 49 71 69 68 87 82 17 23 27 48 49 68 69 71 87 82 17 23 27 48 49 68 69 71 87 82 17 23 27 48 49 68 69 71 82 87

输出说明： 输出每一次划分后数组元素的值。

---

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

#include <stdio.h>
#include<stdlib.h>
void input(int *&a,int & n);
void output(int *a,int n);
void swap(int &a, int &b);
int Partition(int a[],int low,int high);	
void QuickSort(int a[],int s,int t);
int n;
int main ()
{ 
	int i;
	int *a = NULL;	
	input (a,n);
	QuickSort(a, 0, n-1) ;	
	free(a);
	return 0;
}
void input(int *&a,int & n)
{
    int i;
    scanf("%d",&n);    
    if((a=(int *) malloc ((n)*sizeof(int)))==NULL)
    {
        printf("不能成功分配内存单元\n");
        exit(0);
    }
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }            
}
void output(int *a,int n)
{
    int i;
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
}
void swap(int &a, int &b)
{
    int t;
    t=a;a=b;b=t;
}
/**********定义Partition() 和 QuickSort()函数**********/ 
/********** Begin **********/ 
int Partition(int a[],int low,int high)
{
    int val=a[low];
    while(low<high)
    {
        while(low<high&&a[high]>=val)
            --high;
        a[low]=a[high];
        while(low<high&&a[low]<=val)
            ++low;
        a[high]=a[low];
    }
    a[low]=val;
    return low;
}
void QuickSort(int a[],int s,int t)
{
    int pos;
    if(s<t)
    {
        pos=Partition(a,s,t);
        for(int i=0;i<n;i++)
        {
            printf("%d ",a[i]);
        }
        printf("\n");
        QuickSort(a,s,pos-1);
        QuickSort(a,pos+1,t);
    }
}
/********** End **********/