简述各种排序算法

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define SIZE 10
//起泡排序
void BubbleSort(int  *a ,int size)
{
	int i,j;
	int temp;
	for(i=size-1;i>0;i--)
		for(j=0;j<i;j++)
		{
			if(a[j]>a[j+1])
			{
				temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
}
//直接插入
void InsertSort(int *a,int size)
{
	int i,k;
	int t;
	for(i=1;i<size;i++)
	{
		t=a[i];
		k=i-1;
		while(k>=0&&a[k]>t)
		{
			a[k+1]=a[k];
			k--;
		}
		a[k+1]=t;
	}
}
//简单选择
void SelectSort(int *a,int size)
{
	int i,j;
	int temp;
	int min;
	int MinIndex;
	for(i=0;i<size-1;i++)
	{
		MinIndex=i;
		min=a[i];
		for(j=i+1;j<size;j++)
			if(a[j]<min)
			{
				min=a[j];
				MinIndex=j;
			}
			if(MinIndex!=i)
			{
				temp=a[i];
				a[i]=a[MinIndex];
                a[MinIndex]=temp;
			}
	}
}
//快速排序
int Partition(int *a,int low,int high)
{
	int k=a[low];
	while(low<high)
	{
		while(low<high && a[high]>=k) --high;
		a[low]=a[high];
		while(low<high && a[high]<=k) ++low;
		a[high]=a[low];
	}
	a[low]=k;
	return low;
}

void QuickSort(int *a,int low,int high)
{
    int k;
    if(low<high)
    {
		k = Partition(a,low,high);
		QuickSort(a,low,k-1);
		QuickSort(a,k+1,high);
    }
}
//希尔排序
void ShellSort(int *a,int size)
{
    int i,j,h;
    int t;
    h= size/2;
    while(h>0)
    {
    	for(j=h;j<size;j++)
	{
	    t = a[j];
        i = j-h;
	    while(i>=0 && a[i]>t)//用a[j]插入之前的间隔h的序列
	    {
			a[i+h]=a[i];
			i=i-h;
	    }
	    a[i+h]=t;	
	}
	h=h/2;//缩小间隔，直到
    }
}
//堆排序
void HeapAdjust(int *a,int n,int m)
{
    int j;
    int t;
    t=a[m];
    j=2*(m+1)-1;
    while(j<=n)
    {
	if(j<n && a[j]<a[j+1]) j++;
    	if(t<a[j])
    	{
	    a[m]=a[j];
        m=j;
        j=2*(m+1)-1;
	}
	else
        j = n+1;
    }
    a[m]=t;
}

void HeapSort(int *a,int size)
{
    int i,k;
    int t;
    k = size/2;
    for(i=k-1;i>=0;i--) HeapAdjust(a,size-1,i);
    for(i = size-1;i>=0;i--)
    {
        t=a[0];
        a[0]=a[i];
        a[i]=t;
        HeapAdjust(a,i-1,0);
    }
}

int main(void)
{
	int i;
	int Array[SIZE];
	srand((long)time(NULL));
	// 起泡
	printf("原始数据: ");
	for(i=0; i<SIZE; i++)
	{
		Array[i] = rand()%80;
		printf("%d ", Array[i]);
	}
	printf("\n");
	BubbleSort(Array, SIZE);
	printf("起泡排序: ");
	for(i=0; i<SIZE; i++)
		printf("%d ", Array[i]);
	printf("\n\n");

	// 直接插入
	printf("原始数据: ");
	for(i=0; i<SIZE; i++)
	{
		Array[i] = rand()%80;
		printf("%d ", Array[i]);
	}
	printf("\n");
	InsertSort(Array, SIZE);
	printf("直接插入: ");
	for(i=0; i<SIZE; i++)
		printf("%d ", Array[i]);
	printf("\n\n");

	// 简单选择
	printf("原始数据: ");
	for(i=0; i<SIZE; i++)
	{
		Array[i] = rand()%80;
		printf("%d ", Array[i]);
	}
	printf("\n");
	SelectSort(Array, SIZE);
printf("简单选择: ");
	for(i=0; i<SIZE; i++)
		printf("%d ", Array[i]);
	printf("\n\n");

	// 快速排序
	printf("原始数据: ");
	for(i=0; i<SIZE; i++)
	{
		Array[i] = rand()%80;
		printf("%d ", Array[i]);
	}
	printf("\n");
	QuickSort(Array, 0, SIZE-1);
	printf("快速排序: ");
	for(i=0; i<SIZE; i++)
		printf("%d ", Array[i]);
	printf("\n\n");

	// 希尔排序
	printf("原始数据: ");
	for(i=0; i<SIZE; i++)
	{
		Array[i] = rand()%80;
		printf("%d ", Array[i]);
	}
	printf("\n");
	ShellSort(Array, SIZE);
	printf("希尔排序: ");
	for(i=0; i<SIZE; i++)
		printf("%d ", Array[i]);
	printf("\n\n");

	// 堆排序
	printf("原始数据: ");
	for(i=0; i<SIZE; i++)
	{
		Array[i] = rand()%80;
		printf("%d ", Array[i]);
	}
	printf("\n");
	HeapSort(Array, SIZE);
	printf("堆排序:   ");
	for(i=0; i<SIZE; i++)
		printf("%d ", Array[i]);
	printf("\n\n");
	return 0;
}

简述六种排序算法的基本思想：

（1）直接插入排序的基本思想是：当插入第i个数据元素k时，由前i-1个数据元素组成已排序的数据元素序列，将k的关键字与序列中各数据元素的关键字依次进行比较后，找到该插入位置j，并将第j以及后面的数据元素顺序后移一个位置，然后将k插入到位置j，使得插入后的数据元素序列仍是排序的。

（2）希尔排序的基本思想是：先将整个待排序记录序列按给定的下标增量进行分组，并对组内的记录采用直接插入排序，再减小下标增量，即每组包含的记录增多，再继续对每组组内的记录采用直接插入排序；以此类推，当下标增量减小到1时，整个待排序记录已成为一组，再对全体待排序记录进行一次直接插入排序即可完成排序工作。

（3）冒泡排序的基本思想是：将相邻的两个数据元素按关键字进行比较，如果反序，则交换。对于一个待排序的数据元素序列，经一趟排序后最大值数据元素移到最大位置，其它值较大的数据元素向也最终位置移动，此过程为一次起泡。然后对下面的记录重复上述过程直到过程中没有交换为止，则已完成对记录的排序。

（4）选择排序的基本思想是：设有N个数据元素的序列，第一趟排序，比较N个数据元素，选择关键字最小的数据元素，将其交换到序列的第1个位置上；第2趟排序，在余下的N-1个数据元素中，再选取关键字最小的数据元素，交换到序列的第2个位置上；继续进行，经过N-1趟排序，N个数据元素则按递增次序排列完成。

（5）快速排序的基本思想是：在待排序记录序列中，任取其中的一个记录（这里取了第一个）并以该记录的关键字作为基准，经过一趟排序后，所有关键字比它小的记录都交换到它的左边，比它大的记录都交换到它的右边。然后再分别对划分到它的左、右两部分记录序列重复上述过程，直至每一部分最终划分为一个记录时为止即完成了排序工作。

（6）堆排序排序的基本思想是：在排序过程中，将记录数组R[1…n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子节点的内在关系用筛选法将待排序的数据元素序列建成堆，得到最大值—根节点的值。将根节点值向后交换，再将余下的根调整成堆，重复进行直到排序完成。