簡述各種排序算法

#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]看成是一棵完全二叉樹的順序存儲結構，利用完全二叉樹中雙親節點和孩子節點的內在關係用篩選法將待排序的數據元素序列建成堆，得到最大值—根節點的值。將根節點值向後交換，再將餘下的根調整成堆，重複進行直到排序完成。