选择类排序

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

任务描述

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

测试说明

平台会对你编写的代码进行测试,
输入格式：
第一行先给出非负整数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<limits.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;	
	scanf("%d",&n);
	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){
	a = (int*)malloc(sizeof(int)*n);
	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]);
	 printf("\n");
}

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

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

第2关：简单选择排序

任务描述

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

测试说明

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

测试输入：
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;
}
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");
}
/**********定义函数**********/ 
/********** Begin **********/ 
void SelectSort(int *L,int n){
	int t;
	for(int i = 0; i < n-1; i++){
		int k = i;
		for(int j = i+1; j < n; j++){
			if(L[k]>L[j])
			k = j;
		}
		t = L[k];
		L[k] = L[i];
		L[i] = t;
		SelectMinKey(L,0,n);
	}
}
int SelectMinKey(int *L,int i,int n){
	for(int j = i; j < n; j++)
		printf("%d ",L[j]);
		printf("\n");
}
/********** End **********/

第3关：堆排序

任务描述

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

测试说明

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

测试输入：
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 build_heap(int* a,int n); 
void HeapSort(int *a,int n);  
int main ()  
{   
    int i,n,m;  
    int *a = NULL;      
    input (a,n);  
    HeapSort (a,n) ;  
    output(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;  
}  
/**********定义函数**********/   
/********** Begin **********/   
void HeapAdjust(int *a, int s, int m)
{ // s代表节点数，i代表对哪个进行heapadjust
	if(m>=s)
	return ;
	int mx = m; //设m是要做heapAdjust操作最大值下标
	int left = 2 * m + 1;
	int right = 2 * m + 2;
	if (a[left] > a[mx] && left < s)
	{
		mx = left;
	}
	if (a[right] > a[mx] && right < s)
	{
		mx = right;
	}
	if (mx != m)
	{
		swap(a[mx], a[m]);
		HeapAdjust(a, s, mx);
	}
}
void build_heap(int *a, int n)
{ //乱序交换
	int last_node = n - 1;
	int parent = (last_node - 1) / 2;
	for (int i = parent; i >= 0; i--)
	{
		HeapAdjust(a, n, i);
	}
}
void HeapSort(int *a, int n)
{ //找到最后一个子节点与堆顶交换

	build_heap(a, n);
	output(a, n);
	for (int i = n - 1; i >= 1; i--)
	{
		swap(a[i], a[0]);
		output(a, n);
		HeapAdjust(a, i, 0);
		if (i == 1)
			return;
		output(a, n);
	}
}
/********** End **********/