运用各种排序算法完成数组数据的排序

运用各种排序算法完成数组数据的排序（插入排序、希尔排序、堆排序、快速排序、归并排序、基数排序对元素进行排序）

一、明确问题

实验目的：掌握各种排序算法
实验内容：
运用插入排序、希尔排序、堆排序、快速排序、归并排序、基数排序对元素进行排序。关键码序列（503,087,512,061,908,170,897,275,653,426）

二、问题分析

三、主要函数和伪代码

以下为本次实验所使用的子函数：（代码中包含直接插入排序、快速排序、希尔排序、简单选择排序、堆排序、归并排序、基数排序七种）具体代码参考第四大点。
void insertsort(int a[])
int Partition(int a[],int low,int high)
void Qsort(int a[],int low,int high)
void creat(int a[],int *s)
void shellSort(int *a, int n)
void print(int a[])
void SelectSort(int a[])
void swap(int *arr,int i,int j)
void heapify(int *s,int n,int i)
void build_heap(int *s,int n)
void heap_sort(int *s, int n)
void merge(int a[],int l,int r,int mid)
void merge_sort(int a[],int l,int r)
void mergesort(int a[],int l,int r)
int get_max(int a[], int n)
void count_sort(int a[], int n, int exp)
void radix_sort(int a[], int n)

四、源代码和运行结果

#include <stdio.h> 
#include <string.h>
#include <stdlib.h>

void insertsort(int a[]){
	int S[11];
	int i,j;
	for(i=1;i<11;i++)S[i]=a[i-1];
	
	for(i=2;i<=10;i++){
		if(S[i]<S[i-1]){
			S[0]=S[i];
			S[i]=S[i-1];
			for(j=i-2;S[0]<S[j];j--)
			   S[j+1]=S[j];
			S[j+1]=S[0];   
		}
	}
	for(i=1;i<11;i++) printf("%d ",S[i]);
}

int Partition(int a[],int low,int high){
	int pivot;
	int i,j;
	pivot=a[low];i=low;j=high;
	while(i<j){
		while(i<j && a[j]>=pivot) j--;
		a[i]=a[j];
		while(i<j && a[i]<=pivot) i++;
		a[j]=a[i];
	}
	a[i]=pivot;
	return i;
}

void Qsort(int a[],int low,int high){
	int k;
	if(low<high){
		k=Partition(a,low,high);
		Qsort(a,low,k-1);
		Qsort(a,k+1,high);
	}
}

void  creat(int a[],int *s){
	int i;
	for(i=0;i<10;i++) s[i]=a[i];
}

void shellSort(int *a, int n)
{
    int i, j, k, tmp, gap;  // gap 为步长
    for (gap = n / 2; gap > 0; gap /= 2) {  // 步长初始化为数组长度的一半，每次遍历后步长减半,
    	for (i = 0; i < gap; ++i) { // 变量 i 为每次分组的第一个元素下标 
	        for (j = i + gap; j < n; j += gap) { //对步长为gap的元素进行直插排序，当gap为1时，就是直插排序
	            tmp = a[j];  // 备份a[i]的值
	            k = j - gap;  // j初始化为i的前一个元素（与i相差gap长度）
	            while (k >= 0 && a[k] > tmp) {
	                a[k + gap] = a[k]; // 将在a[i]前且比tmp的值大的元素向后移动一位
	                k -= gap;
	            }
	            a[k + gap] = tmp; 
	        }
	    }
    }
}


void print(int a[]){
	int i;
	for(i=0;i<10;i++)printf("%d ",a[i]);
}

void SelectSort(int a[]){
	int i,j,k;
	int tmp;
	for(i=0;i<10;i++){
		k=i;
		for(j=i+1;j<10;j++)
		   if(a[j]<a[k]) k=j;
		if(k!=i){
			tmp=a[i];
			a[i]=a[k];
			a[k]=tmp;
		}
	} 
	print(a);
}

void swap(int *arr,int i,int j){
	int temp=arr[i];
	arr[i]=arr[j];
	arr[j]=temp; 
}

void heapify(int *s,int n,int i){
	int c1=2*i+1;
	int c2=2*i+2;
	int max=i;
	if(c1<n && s[c1]>s[max]){
		max=c1;
	}
	if(c2<n && s[c2]>s[max]){
		max=c2;
	}
	if(max!=i){
		swap(s,max,i);
		heapify(s,n,max);
	}
}

void build_heap(int *s,int n){
	int last_node=n-1;
	int parent=(last_node-1)/2;
	int i;
	for(i=parent;i>=0;i--){
		heapify(s,n,i);
	}
}

void heap_sort(int *s, int n){
	build_heap(s,n);
	int i;
	for(i=n-1;i>=0;i--){
		swap(s,i,0);
		heapify(s,i,0);
	}
} 

void merge(int a[],int l,int r,int mid){  
   int aux[r-l+1],i,j,k;
   for(k=l;k<=r;k++)
   aux[k-l]=a[k];
   i=l; 
   j=mid+1;  
   for(k=l;k<=r;k++) {  
       	if(i>mid){ 
		   	a[k]=aux[j-l];
			j++;	
		}
		else if(j>r){
		    a[k]=aux[i-l];
			i++;
		}
		else if(aux[i-l]>aux[j-l]){
		    a[k]=aux[j-l];
			j++;
		}
		else{
		    a[k]=aux[i-l];
			i++;
		}
	}
} 

void merge_sort(int a[],int l,int r){    
   if(l>=r)
   return ;		
   int mid=(l+r)/2;		
   merge_sort(a,l,mid);	
   merge_sort(a,mid+1,r);	
   merge(a,l,r,mid);
}  

void mergesort(int a[],int l,int r){	
  merge_sort(a,l,r-1);
}


int get_max(int a[], int n)
{
    int i, max;

    max = a[0];
    for (i = 1; i < n; i++)
        if (a[i] > max)
            max = a[i];
    return max;
}

void count_sort(int a[], int n, int exp)
{
    int output[n];             // 存储"被排序数据"的临时数组
    int i, buckets[10] = {0};
    // 将数据出现的次数存储在buckets[]中
    for (i = 0; i < n; i++)
        buckets[ (a[i]/exp)%10 ]++;
    // 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
    for (i = 1; i < 10; i++)
        buckets[i] += buckets[i - 1];
    // 将数据存储到临时数组output[]中
    for (i = n - 1; i >= 0; i--)
    {
        output[buckets[ (a[i]/exp)%10 ] - 1] = a[i];
        buckets[ (a[i]/exp)%10 ]--;
    }
    // 将排序好的数据赋值给a[]
    for (i = 0; i < n; i++)
        a[i] = output[i];
}

void radix_sort(int a[], int n)
{
    int exp;    // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
    int max = get_max(a, n);    // 数组a中的最大值

    // 从个位开始，对数组a按"指数"进行排序
    for (exp = 1; max/exp > 0; exp *= 10)
        count_sort(a, n, exp);
}

main(){
	int a[10]={503,87,512,61,908,170,897,275,653,426};
	int s[10];	int n=10;
	
	printf("原数组序列：\n");
	print(a);
	
	printf("\n\n直接插入排序：\n");
	insertsort(a);
	
	printf("\n\n快速排序：\n");
	int low,high;
	low=0;high=9;
	creat(a,s);
	Qsort(s,low,high);
	print(s);
	
	printf("\n\n希尔排序：\n");
	creat(a,s);
	shellSort(s, n);
	print(s);
	
	printf("\n\n简单选择排序:\n");
	creat(a,s);
	SelectSort(s);
	
	printf("\n\n堆排序：\n");
	creat(a,s);
	heap_sort(s,n);
	print(s);
	
	printf("\n\n归并排序：\n");
	creat(a,s);
	mergesort(s,0,n);
	print(s);
	
	printf("\n\n基数排序：\n");
	creat(a,s);
	radix_sort(s, n);
	print(s);
}