八種常見的排序算法

插入排序

1.直接插入排序

原理：將數組分爲無序區和有序區兩個區，而後不斷將無序區的第一個元素按大小順序插入到有序區中去，最終將全部無序區元素都移動到有序區完成排序。

要點：設立哨兵，做爲臨時存儲和判斷數組邊界之用。

實現：

void InsertSort(Nodetype p[],int length)
{
    int i,j;//分別爲有序區和無序區指針
    for(i=1;i<length;i++)//逐步擴大有序區
    {
        j=i+1;
        if(p[j]<p[i])

        {
            p[0]=p[j];//存儲待排序元素
            while(p[0]<p[i])//查找在有序區中的插入位置，同時移動元素
            {
                p[i+1]=p[i];//移動
                i--;
            }
            p[i+1]=p[0];//將元素插入
        }
        i=j-1;//還原有序區指針
    }
}

2.希爾排序

原理：又稱增量縮小排序。先將序列按增量劃分爲元素個數相同的若干組，使用直接插入排序法進行排序，而後不斷縮小增量直至爲1，最後使用直接插入排序完成排序。

要點：增量的選擇以及排序最終以1爲增量進行排序結束。

實現：

void ShellSort(Nodetype p[],int d)
{
    while(d>=1)//直到增量縮小爲1
    {
        Shell(p,d);
        d=d/2;//縮小增量
    }
}
void Shell(Nodetype p[],int d)
{
    int i,j;
    int length=strlen(p);
    for(i=d+1;i<length)
    {
        if(p[i]<p[i-d])
        {
            p[0]=p[i];
            j=i-d;
            while(j>0&&p[j]>p[0])
            {
                p[j+d]=p[j];
                j=j-d;
            }
            p[j+d]=p[0];
        }
    }
}

交換排序

1.冒泡排序

原理：將序列劃分爲無序和有序區，不斷經過交換較大元素至無序區尾完成排序。

要點：設計交換判斷條件，提早結束以排好序的序列循環。

實現:

void BubbleSort(Nodetype p[])
{
    int i,j;
    int ischanged;//設計跳出條件
    for(j=n-1;j<0;j--)
    {
        ischanged=0;
        for(i=0;i<j;i++)
        {
            if(p[i]>p[i+1])//若是發現較重元素就向後移動
            {
                int temp=p[i];
                p[i]=p[i+1];
                p[i+1]=temp;
                ischanged=1;
            }
        }
        if(!ischanged)//若沒有移動則說明序列已經有序，直接跳出
            break;
    }
}

2.快速排序

原理：不斷尋找一個序列的中點，而後對中點左右的序列遞歸的進行排序，直至所有序列排序完成，使用了分治的思想。

要點：遞歸、分治

基本思想：

1．先從數列中取出一個數做爲基準數。

2．分區過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊。

3．再對左右區間重複第二步，直到各區間只有一個數。

 

選擇排序

1.直接選擇排序

原理：將序列劃分爲無序和有序區，尋找無序區中的最小值和無序區的首元素交換，有序區擴大一個，循環最終完成所有排序。

要點：

實現：

void SelectSort(Nodetype p[],int length)
{
    int i,j,k;//分別爲有序區，無序區，無序區最小元素指針
    for(i=0;i<length;i++)
    {
        k=i;
        for(j=i+1;j<length;j++)
            if(p[j]<p[k]) k=j;
        if(k!=i)//若發現最小元素，則移動到有序區
        {
            int tmp=p[k];
            p[k]=p[i];
            p[i]=tmp;
        }
    }
}

2.堆排序

原理：利用大根堆或小根堆思想，首先創建堆，而後將堆首與堆尾交換，堆尾以後爲有序區。

要點：建堆、交換、調整堆

操做過程以下：

     1)初始化堆：將R[1..n]構造爲堆；

     2)將當前無序區的堆頂元素R[1]同該區間的最後一個記錄交換，而後將新的無序區調整爲新的堆。

    所以對於堆排序，最重要的兩個操做就是構造初始堆和調整堆，其實構造初始堆事實上也是調整堆的過程，只不過構造初始堆是對全部的非葉節點都進行調整。

    下面舉例說明：

     給定一個整形數組a[]={16,7,3,20,17,8}，對其進行堆排序。

    首先根據該數組元素構建一個徹底二叉樹，獲得

 

 而後須要構造初始堆，則從最後一個非葉節點開始調整，調整過程以下：

20和16交換後致使16不知足堆的性質，所以需從新調整

(初始堆)

這樣就獲得了初始堆。即每次調整都是從父節點、左孩子節點、右孩子節點三者中選擇最大者跟父節點進行交換(交換以後可能形成被交換的孩子節點不知足堆的性質，所以每次交換以後要從新對被交換的孩子節點進行調整)。

有了初始堆以後就能夠進行排序了

此時3位於堆頂不滿堆的性質，則需調整繼續調整

接下來和倒數第二個元素交換，再調整

 這樣整個區間便已經有序了。

總結：從上述過程可知，堆排序其實也是一種選擇排序，是一種樹形選擇排序。只不過直接選擇排序中，爲了從R[1...n]中選擇最大記錄，需比較n-1次，而後從R[1...n-2]中選擇最大記錄需比較n-2次。事實上這n-2次比較中有不少已經在前面的n-1次比較中已經作過，而樹形選擇排序剛好利用樹形的特色保存了部分前面的比較結果，所以能夠減小比較次數。對於n個關鍵字序列，最壞狀況下每一個節點需比較log2(n)次，所以其最壞狀況下時間複雜度爲nlogn。堆排序爲不穩定排序，不適合記錄較少的排序。

 

歸併排序

原理：將原序列劃分爲有序的兩個序列，而後利用歸併算法進行合併，合併以後即爲有序序列。

要點：歸併、分治

實現：

Void MergeSort(Node L[],int m,int n)

{

Int k;

If(m<n)

{

K=(m+n)/2;

MergeSort(L,m,k);

MergeSort(L,k+1,n);

Merge(L,m,k,n);

}

}

 

基數排序

原理：將數字按位數劃分出n個關鍵字，每次針對一個關鍵字進行排序，而後針對排序後的序列進行下一個關鍵字的排序，循環至全部關鍵字都使用過則排序完成。

要點：對關鍵字的選取，元素分配收集。

實現：

Void RadixSort(Node L[],length,maxradix)

{

Int m,n,k,lsp;

k=1;m=1;

Int temp[10][length-1];

Empty(temp); //清空臨時空間

While(k<maxradix) //遍歷全部關鍵字

{

For(int i=0;i<length;i++) //分配過程

{

If(L[i]<m)

Temp[0][n]=L[i];

Else

Lsp=(L[i]/m)%10; //肯定關鍵字

Temp[lsp][n]=L[i];

n++;

}

CollectElement(L,Temp); //收集

n=0;

m=m*10;

k++;

}

}