在要排序的一組數(shù)中，選出最小的一個數(shù)與第一個位置的數(shù)交換；
然后在剩下的數(shù)當(dāng)中再找最小的與第二個位置的數(shù)交換，如此循環(huán)
到倒數(shù)第二個數(shù)和最后一個數(shù)比較為止。
選擇排序是不穩(wěn)定的。算法復(fù)雜度O(n2)--[n的平方]
void select_sort(int *x, int n)
{
int i, j, min, t;
for (i=0; i<n-1; i++) /*要選擇的次數(shù)：0~n-2共n-1次*/
{
min = i; /*假設(shè)當(dāng)前下標(biāo)為i的數(shù)最小，比較后再調(diào)整*/
for (j=i+1; j<n; j++)/*循環(huán)找出最小的數(shù)的下標(biāo)是哪個*/
{
if (*(x+j) < *(x+min))
{
min = j; /*如果后面的數(shù)比前面的小，則記下它的下標(biāo)*/
}
}
if (min != i) /*如果min在循環(huán)中改變了，就需要交換數(shù)據(jù)*/
{
t = *(x+i);
*(x+i) = *(x+min);
*(x+min) = t;
}
}
}
直接插入排序
在要排序的一組數(shù)中，假設(shè)前面(n-1) [n>=2] 個數(shù)已經(jīng)是排
好順序的，現(xiàn)在要把第n個數(shù)插到前面的有序數(shù)中，使得這n個數(shù)
也是排好順序的。如此反復(fù)循環(huán)，直到全部排好順序。
直接插入排序是穩(wěn)定的。算法時間復(fù)雜度O(n2)--[n的平方]
void insert_sort(int *x, int n)
{
int i, j, t;
for (i=1; i<n; i++) /*要選擇的次數(shù)：1~n-1共n-1次*/
{
/*
暫存下標(biāo)為i的數(shù)。注意：下標(biāo)從1開始，原因就是開始時
第一個數(shù)即下標(biāo)為0的數(shù)，前面沒有任何數(shù)，單單一個，認為
它是排好順序的。
*/
t=*(x+i);
for (j=i-1; j>=0 && t<*(x+j); j--) /*注意：j=i-1，j--，這里就是下標(biāo)為i的數(shù)，在它前面有序列中找插入位置。*/
{
*(x+j+1) = *(x+j); /*如果滿足條件就往后挪。最壞的情況就是t比下標(biāo)為0的數(shù)都小，它要放在最前面，j==-1，退出循環(huán)*/
}
*(x+j+1) = t; /*找到下標(biāo)為i的數(shù)的放置位置*/
}
}
冒泡排序
在要排序的一組數(shù)中，對當(dāng)前還未排好序的范圍內(nèi)的全部數(shù)，自上
而下對相鄰的兩個數(shù)依次進行比較和調(diào)整，讓較大的數(shù)往下沉，較
小的往上冒。即：每當(dāng)兩相鄰的數(shù)比較后發(fā)現(xiàn)它們的排序與排序要
求相反時，就將它們互換。
下面是一種改進的冒泡算法，它記錄了每一遍掃描后最后下沉數(shù)的
位置k，這樣可以減少外層循環(huán)掃描的次數(shù)。
冒泡排序是穩(wěn)定的。算法時間復(fù)雜度O(n2)--[n的平方]
void bubble_sort(int *x, int n)
{
int j, k, h, t;
for (h=n-1; h>0; h=k) /*循環(huán)到?jīng)]有比較范圍*/
{
for (j=0, k=0; j<h; j++) /*每次預(yù)置k=0，循環(huán)掃描后更新k*/
{
if (*(x+j) > *(x+j+1)) /*大的放在后面，小的放到前面*/
{
t = *(x+j);
*(x+j) = *(x+j+1);
*(x+j+1) = t; /*完成交換*/
k = j; /*保存最后下沉的位置。這樣k后面的都是排序排好了的。*/
}
}
}
}
希爾排序
在直接插入排序算法中，每次插入一個數(shù)，使有序序列只增加1個節(jié)點，
并且對插入下一個數(shù)沒有提供任何幫助。如果比較相隔較遠距離（稱為
增量）的數(shù)，使得數(shù)移動時能跨過多個元素，則進行一次比較就可能消除
多個元素交換。D.L.shell于1959年在以他名字命名的排序算法中實現(xiàn)
了這一思想。算法先將要排序的一組數(shù)按某個增量d分成若干組，每組中
記錄的下標(biāo)相差d.對每組中全部元素進行排序，然后再用一個較小的增量
對它進行，在每組中再進行排序。當(dāng)增量減到1時，整個要排序的數(shù)被分成
一組，排序完成。
下面的函數(shù)是一個希爾排序算法的一個實現(xiàn)，初次取序列的一半為增量，
以后每次減半，直到增量為1。
希爾排序是不穩(wěn)定的。
void shell_sort(int *x, int n)
{
int h, j, k, t;
for (h=n/2; h>0; h=h/2) /*控制增量*/
{
for (j=h; j<n; j++) /*這個實際上就是上面的直接插入排序*/
{
t = *(x+j);
for (k=j-h; (k>=0 && t<*(x+k)); k-=h)
{
*(x+k+h) = *(x+k);
}
*(x+k+h) = t;
}
}
}
快速排序
快速排序是對冒泡排序的一種本質(zhì)改進。它的基本思想是通過一趟
掃描后，使得排序序列的長度能大幅度地減少。在冒泡排序中，一次
掃描只能確保最大數(shù)值的數(shù)移到正確位置，而待排序序列的長度可能只
減少1。快速排序通過一趟掃描，就能確保某個數(shù)（以它為基準(zhǔn)點吧）
的左邊各數(shù)都比它小，右邊各數(shù)都比它大。然后又用同樣的方法處理
它左右兩邊的數(shù)，直到基準(zhǔn)點的左右只有一個元素為止。它是由
C.A.R.Hoare于1962年提出的。
顯然快速排序可以用遞歸實現(xiàn)，當(dāng)然也可以用棧化解遞歸實現(xiàn)。下面的
函數(shù)是用遞歸實現(xiàn)的，有興趣的朋友可以改成非遞歸的。
快速排序是不穩(wěn)定的。最理想情況算法時間復(fù)雜度O(nlog2n)，最壞O(n2)
void quick_sort(int *x, int low, int high)
{
int i, j, t;
if (low < high) /*要排序的元素起止下標(biāo)，保證小的放在左邊，大的放在右邊。這里以下標(biāo)為low的元素為基準(zhǔn)點*/
{
i = low;
j = high;
t = *(x+low); /*暫存基準(zhǔn)點的數(shù)*/
while (i<j) /*循環(huán)掃描*/
{
while (i<j && *(x+j)>t) /*在右邊的只要比基準(zhǔn)點大仍放在右邊*/
{
j--; /*前移一個位置*/
}
if (i<j)
{
*(x+i) = *(x+j); /*上面的循環(huán)退出：即出現(xiàn)比基準(zhǔn)點小的數(shù)，替換基準(zhǔn)點的數(shù)*/
i++; /*后移一個位置，并以此為基準(zhǔn)點*/
}
while (i<j && *(x+i)<=t) /*在左邊的只要小于等于基準(zhǔn)點仍放在左邊*/
{
i++; /*后移一個位置*/
}
if (i<j)
{
*(x+j) = *(x+i); /*上面的循環(huán)退出：即出現(xiàn)比基準(zhǔn)點大的數(shù)，放到右邊*/
j--; /*前移一個位置*/
}
}
*(x+i) = t; /*一遍掃描完后，放到適當(dāng)位置*/
quick_sort(x,low,i-1); /*對基準(zhǔn)點左邊的數(shù)再執(zhí)行快速排序*/
quick_sort(x,i+1,high); /*對基準(zhǔn)點右邊的數(shù)再執(zhí)行快速排序*/
}
}
堆排序
堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。
堆的定義如下：具有n個元素的序列（h1,h2,...,hn),當(dāng)且僅當(dāng)
滿足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)
時稱之為堆。在這里只討論滿足前者條件的堆。
由堆的定義可以看出，堆頂元素（即第一個元素）必為最大項。完全二叉樹可以
很直觀地表示堆的結(jié)構(gòu)。堆頂為根，其它為左子樹、右子樹。
初始時把要排序的數(shù)的序列看作是一棵順序存儲的二叉樹，調(diào)整它們的存儲順序，
使之成為一個堆，這時堆的根節(jié)點的數(shù)最大。然后將根節(jié)點與堆的最后一個節(jié)點
交換。然后對前面(n-1)個數(shù)重新調(diào)整使之成為堆。依此類推，直到只有兩個節(jié)點
的堆，并對它們作交換，最后得到有n個節(jié)點的有序序列。
從算法描述來看，堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最后一個元素
交換位置。所以堆排序有兩個函數(shù)組成。一是建堆的滲透函數(shù)，二是反復(fù)調(diào)用滲透函數(shù)
實現(xiàn)排序的函數(shù)。
堆排序是不穩(wěn)定的。算法時間復(fù)雜度O(nlog2n)。
滲透建堆
void sift(int *x, int n, int s)
{
int t, k, j;
t = *(x+s); /*暫存開始元素*/
k = s; /*開始元素下標(biāo)*/
j = 2*k + 1; /*右子樹元素下標(biāo)*/
while (j<n)
{
if (j<n-1 && *(x+j) < *(x+j+1))/*判斷是否滿足堆的條件：滿足就繼續(xù)下一輪比較，否則調(diào)整。*/
{
j++;
}
if (t<*(x+j)) /*調(diào)整*/
{
*(x+k) = *(x+j);
k = j; /*調(diào)整后，開始元素也隨之調(diào)整*/
j = 2*k + 1;
}
else /*沒有需要調(diào)整了，已經(jīng)是個堆了，退出循環(huán)。*/
{
break;
}
}
*(x+k) = t; /*開始元素放到它正確位置*/
}
堆排序
void heap_sort(int *x, int n)
{
int i, k, t;
int *p;
for (i=n/2-1; i>=0; i--)
{
sift(x,n,i); /*初始建堆*/
}
for (k=n-1; k>=1; k--)
{
t = *(x+0); /*堆頂放到最后*/
*(x+0) = *(x+k);
*(x+k) = t;
sift(x,k,0); /*剩下的數(shù)再建堆*/
}
}
===============================================================================
void main()
{
#define MAX 4
int *p, i, a[MAX];
/*錄入測試數(shù)據(jù)*/
p = a;
printf("Input %d number for sorting :\n",MAX);
for (i=0; i<MAX; i++)
{
scanf("%d",p++);
}
printf("\n");
/*測試選擇排序*/
p = a;
select_sort(p,MAX);
/**/
/*測試直接插入排序*/
/*
p = a;
insert_sort(p,MAX);
*/
/*測試冒泡排序*/
/*
p = a;
insert_sort(p,MAX);
*/
/*測試快速排序*/
/*
p = a;
quick_sort(p,0,MAX-1);
*/
/*測試堆排序*/
/*
p = a;
heap_sort(p,MAX);
*/
for (p=a, i=0; i<MAX; i++)
{
printf("%d ",*p++);
}
printf("\n");
system("pause");