选择类排序

第1关：编写函数在一个数组中选择最小值

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

---

任务描述

本关任务：编写函数在一个数组一定范围内选择最小值。

相关知识

为了完成本关任务，需要了解如何在数组一定范围内选择最小值。

编程要求

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

• 函数 input()实现一维数组的输入；
• 函数 output()实现一维数组的输出；
• 函数 int SelectMinKey(int *L,int i,int n)，函数返回值为数组L在下标i到n范围内最小值的下标。

测试说明

平台会对你编写的代码进行测试, 输入格式： 第一行先给出非负整数N； 第二行给出N个整数；

输出格式： 第一行输出N个整数； 以后每行输出数组不同范围内最小值的下标。

测试输入： 10 66 37 66 7 34 52 23 85 7 10

预期输出： 66 37 66 7 34 52 23 85 7 10 0,9,3 1,9,3 2,9,3 3,9,3 4,9,8 5,9,8 6,9,8 7,9,8 8,9,8

---

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

#include <stdio.h>
#include<stdlib.h>
#include<time.h>
void input(int *&a,int & n);
void output(int *a,int n);
int SelectMinKey(int *L,int i,int n);
int main ()
{ 
    int i,n,m;
    int *a = NULL;    
    input (a,n);
    output(a,n);
    for(i=0;i<n-1;i++)
    {
        printf("%d,%d,%d\n",i,n-1,SelectMinKey(a,i,n) );
    }
    free(a);
    return 0;
}

/**********定义函数**********/ 
/********** Begin **********/ 
void input(int *&a,int & n)
{
	int i;
	scanf("%d",&n);
	a=(int *)malloc(n*sizeof(int));
	if(a==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");
}

int SelectMinKey(int *L,int i,int n)
{
	int min,j;
	min=i;
	for(j=i+1;j<n;j++)
	{
		if(L[min]>L[j])
		{
			min=j;
		}
	}
	return min;
}

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

第2关：简单选择排序

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

---

任务描述

本关要求通过定义函数void SelectSort(int *a,int n)来实现简单选择排序的功能。

相关知识

简单选择排序算法思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

以长度为n=10的序列（46 74 53 14 26 38 86 65 27 34）的选择排序过程做示范： 第1趟：在10个数中选出最小值后，将最小值和第1个数组元素交换，则数组元素为（14 74 53 46 26 38 86 65 27 34）； 第2趟：在剩下的9个数中选出最小值后，将最小值和第2个数组元素交换，则数组元素为（14 26 53 46 74 38 86 65 27 34）； 第3趟：在剩下的8个数中选出最小值后，将最小值和第3个数组元素交换，则数组元素为（14 26 27 46 74 38 86 65 53 34）； …… 第9趟：在剩下的2个数中选出最小值后，将最小值和第9个数组元素交换，则数组元素为（14 26 27 34 38 46 53 65 74 86）；

共执行9趟操作，可将有n=10个元素的数组排成有序序列。

编程要求

平台会对你编写的代码进行测试，完成下列函数的定义，对数组中的元素实现简单选择排序，并输出每一次排序后的结果。具体请参见后续测试样例。

测试说明

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

测试输入： 10 88 84 23 85 32 34 80 52 91 77

预期输出： 23 84 88 85 32 34 80 52 91 77 23 32 88 85 84 34 80 52 91 77 23 32 34 85 84 88 80 52 91 77 23 32 34 52 84 88 80 85 91 77 23 32 34 52 77 88 80 85 91 84 23 32 34 52 77 80 88 85 91 84 23 32 34 52 77 80 84 85 91 88 23 32 34 52 77 80 84 85 91 88 23 32 34 52 77 80 84 85 88 91 23 32 34 52 77 80 84 85 88 91

提示： 如果有10个整数，要求输出每趟选择排序共9趟的结果。

---

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

#include <stdio.h>
#include<stdlib.h>
void input(int *&a,int & n);
void output(int *a,int n);
int SelectMinKey(int *L,int i,int n);
void SelectSort(int *L,int n);

int main ()
{ 
	int i,n,m;
	int *a = NULL;	
	input (a,n);
	SelectSort (a,n);	
	free(a);
	return 0;
}
/**********定义函数**********/ 
/********** Begin **********/ 
void input(int *&a,int & n)
{
	scanf("%d",&n);
	a=(int *)malloc(n*sizeof(int));
	if(a==NULL)
	{
		exit(0);
	}
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
}
int SelectMinKey(int *L,int i,int n)
{
	int min,j;
	min=i;
	for(j=i+1;j<n;j++)
	{
		if(L[min]>L[j])
		{
			min=j;
		}
	}
	return min;
}

void SelectSort(int *L,int n)
{
	int t,j;
	for(int i=0;i<n-1;i++)
	{
		j=SelectMinKey(L,i,n);
		if(i!=j)
		{
			t=L[i];
			L[i]=L[j];
			L[j]=t;
		}
		for(int k=0;k<n;k++)
		{
			printf("%d ",L[k]);
		}
		printf("\n");
	}
}

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

第3关：堆排序

• 任务描述
• 相关知识
  • 堆定义
  • 堆的高度
  • 堆排序
• 编程要求
• 测试说明

---

任务描述

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

相关知识

堆定义

n个关键字序列Kl，K2，…，Kn称为堆(Heap)，当且仅当该序列满足如下性质(简称为堆性质):

若将此序列所存储的数组R[0…n-1]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树:

树中任一非叶子结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

小顶堆：根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小顶堆，又称最小堆。

大顶堆：根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者，称为大顶堆，又称最大堆。

注意： 该数组从逻辑上讲就是一个堆结构，用简单的公式来描述一下堆的定义就是： 大顶堆：R[i] >= R[2i+1] && R[i] >= R[2i+2]，其中i=0,1,2,…

堆的高度

堆可以被看成是一棵树，定义堆的高度为树根的高度。我们将看到，堆结构上的一些基本操作的运行时间至多是与树的高度成正比，为O(logn)。

堆排序

堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单。

用大根堆排序的基本思想：

①先将初始无序数组R[0..n-1]建成一个大根堆。

②再将关键字最大的数组元素R[0](即堆顶)和无序区的最后一个数组元素R[n-1]交换，由此得到新的无序区R[0..n-2]和有序区R[n-1]，且满足R[0..n-2]≤R[n-1]。

③由于交换后新的根R[0]可能违反堆性质，故应将当前无序区R[0..n-2]调整为堆。然后再次将R[0..n-2]中关键字最大的记录R[0]和该区间的最后一个记录R[n-2]交换，由此得到新的无序区R[0..n-3]和有序区R[n-2..n-1]，且仍满足关系R[0..n-3]≤R[n-2..n-1]，同样要将R[0..n-3]调整为堆。 …… 直到无序区只有一个元素为止。

大根堆排序算法的基本操作:

①建堆：建堆是不断调整堆的过程，从n/2处开始调整，一直到第一个节点，此处n是堆中元素的个数。建堆的过程是线性的过程，从n/2到0处一直调用调整堆的算法，相当于o(h1)+o(h2)…+o(hn/2) 其中h表示节点的深度，n/2表示节点的个数，这是一个求和的过程，结果是线性的O(n)。

 

 

 

 

 

 

 

 

②调整堆：调整堆在构建堆的过程中会用到，而且在堆排序过程中也会用到。利用的思想是比较节点i和它的孩子节点left(i),right(i)，选出三者最大(或者最小)者，如果最大(小)值不是节点i而是它的一个孩子节点，那边交互节点i和该节点，然后再调用调整堆过程，这是一个递归的过程。调整堆的过程时间复杂度与堆的深度有关系，是logn的操作，因为是沿着深度方向进行调整的。

③堆排序：堆排序是利用上面的两个过程来进行的。首先是根据数组元素构建堆。然后将堆的根节点取出(一般是与最后一个节点进行交换)，将前面第1个节点继续进行堆调整的过程，然后再将根节点取出，这样一直到所有节点都取出。堆排序过程的时间复杂度是O(nlogn)。因为建堆的时间复杂度是O(n)(调用一次);调整堆的时间复杂度是logn，调用了n-1次，所以堆排序的时间复杂度是O(nlogn)。

注意 ①只需做n-1趟排序，选出较大的n-1个关键字即可以使得数组递增有序。 ②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。 ③堆排序和直接选择排序相反:在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止。

特点 堆排序是一树形选择排序。堆排序的特点是:在排序过程中，将R[0..n-1]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系(参见二叉树的顺序存储结构实训项目)，在当前无序区中选择关键字最大(或最小)的记录。

编程要求

根据提示，在右侧编辑器补充代码，要求通过定义函数来实现堆排序的功能。

• 函数void HeapAdjust(int* a,int s,int m);实现调整堆的操作
• 函数void HeapSort(int *a,int n);实现堆排序的操作

测试说明

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

测试输入： 10 4 1 3 2 16 9 10 14 8 7

预期输出： 16 14 10 8 7 9 3 2 4 1 1 14 10 8 7 9 3 2 4 16 14 8 10 4 7 9 3 2 1 16 1 8 10 4 7 9 3 2 14 16 10 8 9 4 7 1 3 2 14 16 2 8 9 4 7 1 3 10 14 16 9 8 3 4 7 1 2 10 14 16 2 8 3 4 7 1 9 10 14 16 8 7 3 4 2 1 9 10 14 16 1 7 3 4 2 8 9 10 14 16 7 4 3 1 2 8 9 10 14 16 2 4 3 1 7 8 9 10 14 16 4 2 3 1 7 8 9 10 14 16 1 2 3 4 7 8 9 10 14 16 3 2 1 4 7 8 9 10 14 16 1 2 3 4 7 8 9 10 14 16 2 1 3 4 7 8 9 10 14 16 1 2 3 4 7 8 9 10 14 16 1 2 3 4 7 8 9 10 14 16

输出说明 第1行为根据初始序列建好的大顶堆，最大的元素为堆的根结点R[0]； 第2行输出将R[0]和R[n-1]交换后的所有数组元素，新的无序区R[0..n-2]和有序区R[n-1]，且满足R[0..n-2]≤R[n-1]； 第3行将当前无序区R[0..n-2]调整为堆后输出所有数组元素； 第4行输出将R[0]和R[n-2]交换后的数组元素，且满足R[0..n-3]≤R[n-2]≤R[n-1]； …… 依次继续，直到所有数组元素有序。

---

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

#include <stdio.h>
#include<stdlib.h>
#include<time.h>
void input(int *&a,int & n);
void output(int *a,int n);
void HeapAdjust(int* a,int s,int m) ;
void HeapSort(int *a,int n); 

int main ()
{ 
	int i,n,m;
	int *a = NULL;	
	input (a,n);
	HeapSort (a,n) ;
	free(a);
	return 0;
}
/**********定义函数**********/ 
/********** Begin **********/ 
void input(int *&a,int & n)
{
	scanf("%d",&n);
	a=(int *)malloc((n+1)*sizeof(int));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
}
void HeapAdjust(int* a,int s,int m)
{
	int j;
	a[0]=a[s];
	for(j=2*s;j<=m;j*=2)
	{
		if(j<m&&a[j]<a[j+1])
			j++;
		if(a[0]>=a[j])
			break;
		a[s]=a[j];
		s=j;
	}
	a[s]=a[0];
}

void HeapSort(int *a,int n)
{
	int i,t;
	for(i=n/2;i>0;i--)
		HeapAdjust(a,i,n);
	for(int i=1;i<=n;i++)
	{
		printf("%d ",a[i]);
	}
	printf("\n");
	for(i=n;i>1;i--)
	{
		a[0]=a[1];
		a[1]=a[i];
		a[i]=a[0];
		for(int i=1;i<=n;i++)
		{
			printf("%d ",a[i]);
		}
		printf("\n");
		HeapAdjust(a,1,i-1);
		for(int i=1;i<=n;i++)
		{
			printf("%d ",a[i]);
		}
		printf("\n");
	}
}


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