重溫經(jīng)典排序思想--C語(yǔ)言常用排序全解

　　/*

　　===============================================

　　作者：rerli

　　時(shí)間：2003-12-15

　　目的：重溫經(jīng)典排序思想，并用C語(yǔ)言指針實(shí)現(xiàn)排序算法

　　================================================

　　*/

　　/*

　　=============================================================================

　　相關(guān)知識(shí)介紹(所有定義只為幫助讀者理解相關(guān)概念，并非嚴(yán)格定義)：

　　1、穩(wěn)定排序和非穩(wěn)定排序

　　簡(jiǎn)單地說(shuō)就是所有相等的數(shù)經(jīng)過(guò)某種排序方法后，仍能保持它們?cè)谂判蛑暗南鄬?duì)次序，我們就

　　說(shuō)這種排序方法是穩(wěn)定的。反之，就是非穩(wěn)定的。

　　比如：一組數(shù)排序前是a1,a2,a3,a4,a5，其中a2=a4，經(jīng)過(guò)某種排序后為a1,a2,a4,a3,a5，

　　則我們說(shuō)這種排序是穩(wěn)定的，因?yàn)閍2排序前在a4的前面，排序后它還是在a4的前面。假如變成a1,a4,

　　a2,a3,a5就不是穩(wěn)定的了。

　　2、內(nèi)排序和外排序

　　在排序過(guò)程中，所有需要排序的數(shù)都在內(nèi)存，并在內(nèi)存中調(diào)整它們的存儲(chǔ)順序，稱為內(nèi)排序;

　　在排序過(guò)程中，只有部分?jǐn)?shù)被調(diào)入內(nèi)存，并借助內(nèi)存調(diào)整數(shù)在外存中的存放順序排序方法稱為外排序。

　　3、算法的時(shí)間復(fù)雜度和空間復(fù)雜度

　　所謂算法的時(shí)間復(fù)雜度，是指執(zhí)行算法所需要的計(jì)算工作量。

　　一個(gè)算法的空間復(fù)雜度，一般是指執(zhí)行這個(gè)算法所需要的內(nèi)存空間。

　　================================================================================

　　*/

　　/*

　　================================================

　　功能：選擇排序

　　輸入：數(shù)組名稱(也就是數(shù)組首地址)、數(shù)組中元素個(gè)數(shù)

　　================================================

　　*/

　　/*

　　====================================================

　　算法思想簡(jiǎn)單描述：

　　在要排序的一組數(shù)中，選出最小的一個(gè)數(shù)與第一個(gè)位置的數(shù)交換;

　　然后在剩下的數(shù)當(dāng)中再找最小的與第二個(gè)位置的數(shù)交換，如此循環(huán)

　　到倒數(shù)第二個(gè)數(shù)和最后一個(gè)數(shù)比較為止。

　　選擇排序是不穩(wěn)定的。算法復(fù)雜度O(n2)--[n的平方]

　　=====================================================

　　*/

　　void select_sort(int *x, int n)

　　{

　　int i, j, min, t;

　　for (i=0; i {

　　min = i; /*假設(shè)當(dāng)前下標(biāo)為i的數(shù)最小，比較后再調(diào)整*/

　　for (j=i+1; j {

　　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ù)組首地址)、數(shù)組中元素個(gè)數(shù)

　　================================================

　　*/

　　/*

　　====================================================

　　算法思想簡(jiǎn)單描述：

　　在要排序的一組數(shù)中，假設(shè)前面(n-1) [n>=2] 個(gè)數(shù)已經(jīng)是排

　　好順序的，現(xiàn)在要把第n個(gè)數(shù)插到前面的有序數(shù)中，使得這n個(gè)數(shù)

　　也是排好順序的。如此反復(fù)循環(huán)，直到全部排好順序。

　　直接插入排序是穩(wěn)定的。算法時(shí)間復(fù)雜度O(n2)--[n的平方]

　　=====================================================

　　*/

　　void insert_sort(int *x, int n)

　　{

　　int i, j, t;

　　for (i=1; i {

　　/*

　　暫存下標(biāo)為i的數(shù)。注意：下標(biāo)從1開(kāi)始，原因就是開(kāi)始時(shí)

　　第一個(gè)數(shù)即下標(biāo)為0的數(shù)，前面沒(méi)有任何數(shù)，單單一個(gè)，認(rèn)為

　　它是排好順序的。

　　*/

　　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ù)組名稱(也就是數(shù)組首地址)、數(shù)組中元素個(gè)數(shù)

　　================================================

　　*/

　　/*

　　====================================================

　　算法思想簡(jiǎn)單描述：

　　在要排序的一組數(shù)中，對(duì)當(dāng)前還未排好序的范圍內(nèi)的全部數(shù)，自上

　　而下對(duì)相鄰的兩個(gè)數(shù)依次進(jìn)行比較和調(diào)整，讓較大的數(shù)往下沉，較

　　小的往上冒。即：每當(dāng)兩相鄰的數(shù)比較后發(fā)現(xiàn)它們的排序與排序要

　　求相反時(shí)，就將它們互換。

　　下面是一種改進(jìn)的冒泡算法，它記錄了每一遍掃描后最后下沉數(shù)的

　　位置k，這樣可以減少外層循環(huán)掃描的次數(shù)。

　　冒泡排序是穩(wěn)定的。算法時(shí)間復(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 {

　　if (*(x+j) > *(x+j+1)) /*大的放在后面，小的放到前面*/

　　{

　　t = *(x+j);

　　*(x+j) = *(x+j+1);

　　*(x+j+1) = t; /*完成交換*/

　　k = j; /*保存最后下沉的位置。這樣k后面的都是排序排好了的。*/

　　}

　　}

　　}

　　}

　　/*

　　================================================

　　功能：希爾排序

　　輸入：數(shù)組名稱(也就是數(shù)組首地址)、數(shù)組中元素個(gè)數(shù)

　　================================================

　　*/

　　/*

　　====================================================

　　算法思想簡(jiǎn)單描述：

　　在直接插入排序算法中，每次插入一個(gè)數(shù)，使有序序列只增加1個(gè)節(jié)點(diǎn)，

　　并且對(duì)插入下一個(gè)數(shù)沒(méi)有提供任何幫助。如果比較相隔較遠(yuǎn)距離(稱為

　　增量)的數(shù)，使得數(shù)移動(dòng)時(shí)能跨過(guò)多個(gè)元素，則進(jìn)行一次比較就可能消除

　　多個(gè)元素交換。D.L.shell于1959年在以他名字命名的排序算法中實(shí)現(xiàn)

　　了這一思想。算法先將要排序的一組數(shù)按某個(gè)增量d分成若干組，每組中

　　記錄的下標(biāo)相差d.對(duì)每組中全部元素進(jìn)行排序，然后再用一個(gè)較小的增量

　　對(duì)它進(jìn)行，在每組中再進(jìn)行排序。當(dāng)增量減到1時(shí)，整個(gè)要排序的數(shù)被分成

　　一組，排序完成。

　　下面的函數(shù)是一個(gè)希爾排序算法的一個(gè)實(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 {

　　t = *(x+j);

　　for (k=j-h; (k>=0 && t<*(x+k)); k-=h)

　　{

　　*(x+k+h) = *(x+k);

　　}

　　*(x+k+h) = t;

　　}

　　}

　　}

　　/*

　　================================================

　　功能：快速排序

　　輸入：數(shù)組名稱(也就是數(shù)組首地址)、數(shù)組中起止元素的下標(biāo)

　　================================================

　　*/

　　/*

　　====================================================

　　算法思想簡(jiǎn)單描述：

　　快速排序是對(duì)冒泡排序的一種本質(zhì)改進(jìn)。它的基本思想是通過(guò)一趟

　　掃描后，使得排序序列的長(zhǎng)度能大幅度地減少。在冒泡排序中，一次

　　掃描只能確保最大數(shù)值的數(shù)移到正確位置，而待排序序列的長(zhǎng)度可能只

　　減少1。快速排序通過(guò)一趟掃描，就能確保某個(gè)數(shù)(以它為基準(zhǔn)點(diǎn)吧)

　　的左邊各數(shù)都比它小，右邊各數(shù)都比它大。然后又用同樣的方法處理

　　它左右兩邊的數(shù)，直到基準(zhǔn)點(diǎn)的左右只有一個(gè)元素為止。它是由

　　C.A.R.Hoare于1962年提出的。

　　顯然快速排序可以用遞歸實(shí)現(xiàn)，當(dāng)然也可以用棧化解遞歸實(shí)現(xiàn)。下面的

　　函數(shù)是用遞歸實(shí)現(xiàn)的，有興趣的朋友可以改成非遞歸的。

　　快速排序是不穩(wěn)定的。最理想情況算法時(shí)間復(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)點(diǎn)*/

　　{

　　i = low;

　　j = high;

　　t = *(x+low); /*暫存基準(zhǔn)點(diǎn)的數(shù)*/

　　while (i {

　　while (it) /*在右邊的只要比基準(zhǔn)點(diǎn)大仍放在右邊*/

　　{

　　j--; /*前移一個(gè)位置*/

　　}

　　if (i {

　　*(x+i) = *(x+j); /*上面的循環(huán)退出：即出現(xiàn)比基準(zhǔn)點(diǎn)小的數(shù)，替換基準(zhǔn)點(diǎn)的數(shù)*/

　　i++; /*后移一個(gè)位置，并以此為基準(zhǔn)點(diǎn)*/

　　}

　　while (i {

　　i++; /*后移一個(gè)位置*/

　　}

　　if (i {

　　*(x+j) = *(x+i); /*上面的循環(huán)退出：即出現(xiàn)比基準(zhǔn)點(diǎn)大的數(shù)，放到右邊*/

　　j--; /*前移一個(gè)位置*/

　　}

　　}

　　*(x+i) = t; /*一遍掃描完后，放到適當(dāng)位置*/

　　quick_sort(x,low,i-1); /*對(duì)基準(zhǔn)點(diǎn)左邊的數(shù)再執(zhí)行快速排序*/

　　quick_sort(x,i+1,high); /*對(duì)基準(zhǔn)點(diǎn)右邊的數(shù)再執(zhí)行快速排序*/

　　}

　　}

　　/*

　　================================================

　　功能：堆排序

　　輸入：數(shù)組名稱(也就是數(shù)組首地址)、數(shù)組中元素個(gè)數(shù)

　　================================================

　　*/

　　/*

　　====================================================

　　算法思想簡(jiǎn)單描述：

　　堆排序是一種樹(shù)形選擇排序，是對(duì)直接選擇排序的有效改進(jìn)。

　　堆的定義如下：具有n個(gè)元素的序列(h1,h2,...,hn),當(dāng)且僅當(dāng)

　　滿足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1)(i=1,2,...,n/2)

　　時(shí)稱之為堆。在這里只討論滿足前者條件的堆。

　　由堆的定義可以看出，堆頂元素(即第一個(gè)元素)必為最大項(xiàng)。完全二叉樹(shù)可以

　　很直觀地表示堆的結(jié)構(gòu)。堆頂為根，其它為左子樹(shù)、右子樹(shù)。

　　初始時(shí)把要排序的數(shù)的序列看作是一棵順序存儲(chǔ)的二叉樹(shù)，調(diào)整它們的存儲(chǔ)順序，

　　使之成為一個(gè)堆，這時(shí)堆的根節(jié)點(diǎn)的數(shù)最大。然后將根節(jié)點(diǎn)與堆的最后一個(gè)節(jié)點(diǎn)

　　交換。然后對(duì)前面(n-1)個(gè)數(shù)重新調(diào)整使之成為堆。依此類推，直到只有兩個(gè)節(jié)點(diǎn)

　　的堆，并對(duì)它們作交換，最后得到有n個(gè)節(jié)點(diǎn)的有序序列。

　　從算法描述來(lái)看，堆排序需要兩個(gè)過(guò)程，一是建立堆，二是堆頂與堆的最后一個(gè)元素

　　交換位置。所以堆排序有兩個(gè)函數(shù)組成。一是建堆的滲透函數(shù)，二是反復(fù)調(diào)用滲透函數(shù)

　　實(shí)現(xiàn)排序的函數(shù)。

　　堆排序是不穩(wěn)定的。算法時(shí)間復(fù)雜度O(nlog2n)。

　　*/

　　/*

　　功能：滲透建堆

　　輸入：數(shù)組名稱(也就是數(shù)組首地址)、參與建堆元素的個(gè)數(shù)、從第幾個(gè)元素開(kāi)始

　　*/

　　void sift(int *x, int n, int s)

　　{

　　int t, k, j;

　　t = *(x+s); /*暫存開(kāi)始元素*/

　　k = s; /*開(kāi)始元素下標(biāo)*/

　　j = 2*k + 1; /*右子樹(shù)元素下標(biāo)*/

　　while (j {

　　if (j {

　　j++;

　　}

　　if (t<*(x+j)) /*調(diào)整*/

　　{

　　*(x+k) = *(x+j);

　　k = j; /*調(diào)整后，開(kāi)始元素也隨之調(diào)整*/

　　j = 2*k + 1;

　　}

　　else /*沒(méi)有需要調(diào)整了，已經(jīng)是個(gè)堆了，退出循環(huán)。*/

　　{

　　break;

　　}

　　}

　　*(x+k) = t; /*開(kāi)始元素放到它正確位置*/

　　}

　　/*

　　功能：堆排序

　　輸入：數(shù)組名稱(也就是數(shù)組首地址)、數(shù)組中元素個(gè)數(shù)

　　*/

　　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];

　　/*錄入測(cè)試數(shù)據(jù)*/

　　p = a;

　　printf("Input %d number for sorting :n",MAX);

　　for (i=0; i {

　　scanf("%d",p++);

　　}

　　printf("n");

　　/*測(cè)試選擇排序*/

　　p = a;

　　select_sort(p,MAX);

　　/**/

　　/*測(cè)試直接插入排序*/

　　/*

　　p = a;

　　insert_sort(p,MAX);

　　*/

　　/*測(cè)試冒泡排序*/

　　/*

　　p = a;

　　insert_sort(p,MAX);

　　*/

　　/*測(cè)試快速排序*/

　　/*

　　p = a;

　　quick_sort(p,0,MAX-1);

　　*/

　　/*測(cè)試堆排序*/

　　/*

　　p = a;

　　heap_sort(p,MAX);

　　*/

　　for (p=a, i=0; i {

　　printf("%d ",*p++);

　　}

　　printf("n");

　　system("pause");

　　}