各種排序算法的實現及其比較

本人介紹的排序算法主要有：插入排序，選擇排序，冒泡排序，快速排序，堆排序，歸並排序，希爾排序，二叉樹排序，桶排序，基數排序（后兩者為非比較排序，前面的為比較排序）。

 

排序的穩定性和復雜度：

      不穩定：

      選擇排序（selection sort）— O(n²)

      快速排序（quicksort）— O(nlogn) 平均時間, O(n²) 最壞情況; 對於大的、亂序串列一般認為是最快的已知排序

      堆排序 （heapsort）— O(nlogn)

      希爾排序 （shell sort）— O(nlogn)

      基數排序（radix sort）— O(n·k); 需要 O(n) 額外存儲空間 （K為特征個數）

 

      穩定：

      插入排序（insertion sort）— O(n²)

      冒泡排序（bubble sort） — O(n²)

      歸並排序 （merge sort）— O(nlogn); 需要 O(n) 額外存儲空間

      二叉樹排序（Binary tree sort） — O(nlogn); 需要 O(n) 額外存儲空間

      桶排序 （bucket sort）— O(n); 需要 O(k) 額外存儲空間

 

1、插入排序

     對於一個序列{a[0]……a[n]}，當記錄值是第i個元素時，前面i-1個元素已經排好序了，那么這個記錄值從第i-1個元素一直往前比較，找到屬於它的位置后插進去。

#include <iostream>
using  namespace std;

int main()
{
    int a[]={1,99,2,88,3,77,4,66};
    int n=sizeof(a)/4;
    for(int i=0; i<n; i++)
    {
        int tp=a[i], j;
        for(j=i-1; j>=0&&a[j]>tp; j--) a[j+1]=a[j];
        a[j+1]=tp;
    }
    cout << a[0] ;
    for(int i=1; i<n; i++) cout << " " << a[i];
    cout <<endl;
    return 0;
}

 

 

2、選擇排序

    對於一個序列{a[0]……a[n]}，前面i-1個元素都是已經排好序的，那么從第i到第n個元素，找到最小值的那個元素，如果下標不是i，則讓第i個元素和那個最小的元素位置互換。

#include <iostream>
using  namespace std;

int main()
{
    int a[]={1,99,2,88,3,77,4,66};
    int n=sizeof(a)/4;
    for(int i=0; i<n; i++)
    {
        int pos=-1, minn=a[i];
        for(int j=i+1; j<n; j++)
        {
            if(a[j]<minn) minn=a[j], pos=j;
        }
        if(pos!=-1) swap(a[i],a[pos]);
    }
    cout << a[0] ;
    for(int i=1; i<n; i++) cout << " " << a[i];
    cout <<endl;
    return 0;
}

 

3、冒泡排序

    冒泡排序顧名思義就是從最后往前兩個元素開始進行兩兩比較，如果a[i]小於a[i-1]，那么讓他們互換位置，每比較一輪必有一個最小的元素冒泡到這些所比較元素的前面。

#include <iostream>
using  namespace std;

int main()
{
    int a[]={1,99,2,88,3,77,4,66};
    int n=sizeof(a)/4;
    for(int i=0; i<n; i++)
    {
        for(int j=n-1; j>i; j--)
            if(a[j]<a[j-1]) swap(a[j],a[j-1]);
    }
    cout << a[0] ;
    for(int i=1; i<n; i++) cout << " " << a[i];
    cout <<endl;
    return 0;
}

 

4、快速排序

    基本思想就是取一個數作為中間數（一般是取第一個數作為中間數），小於它的都放到左邊，大於它的都放到右邊，再對每一邊利用同樣的思想進行處理。

#include <iostream>
using  namespace std;

void QuickSort(int *a, int l, int r)
{
    if(a==NULL||l>=r) return ;

    int i=l, j=r, tmp=a[l];
    while(i<j)
    {
        while(j>i&&a[j]>=tmp) j--;
        a[i]=a[j];
        while(i<j&&a[i]<=tmp) i++;
        a[j]=a[i];
    }
    a[i]=tmp;
    QuickSort(a,l,i-1);
    QuickSort(a,i+1,r);
}

int main()
{
    int a[]= {1,99,2,88,3,77,4,66};
    int n=sizeof(a)/4;
    QuickSort(a,0,n-1);
    cout << a[0] ;
    for(int i=1; i<n; i++) cout << " " << a[i];
    cout <<endl;
    return 0;
}

 

5、堆排序

堆排序其實要利用到二叉堆，二叉堆其實完全可以理解為一顆有限制的完全二叉樹。

二叉堆的定義：二叉堆可以分為最大堆和最小堆。最大堆為對於所有節點它的左右節點權值一定比它小，最小堆為對於所有節點它的左右節點權值一定比它大。

二叉堆的插入：將一個序列下表從0開始一個一個往堆里插入，因為滿足完全二叉樹性質，所以這么做是可行的。對於插入的第i個數，那么從下往上，它的父親節點為（i-1）/2個數，再根據二叉堆的性質進行調整。

二叉堆的刪除：每次進行一次堆調整之后，根節點必是最大的（最大堆），每次把根節點a[0]取出和數組第n個數互換，然后再用數組第1個到第n-1個數再次建堆，如此反復取出再建堆，那么得到的新序列必是一個有序序列。

#include <iostream>
using  namespace std;

void BuildHeap(int *a, int i, int n)  //建二叉堆
{
    int j=(i-1)/2;  //j為i節點的父親節點
    while(i>0)
    {
        if(a[j]>=a[i]) break;
        swap(a[i],a[j]);
        i=j;
        j=(i-1)/2;
    }
}

void MaxHeapSort(int *a, int i, int n)  //二叉堆排序
{
    int j=2*i+1, tmp=a[i];
    while(j<n)
    {
        if(a[j+1]>a[j]&&j+1<n) j++; //選出i節點左右孩子節點的最大值
        if(tmp>=a[j]) break;
        a[i]=a[j];
        i=j;
        j=2*i+1;
    }
    a[i]=tmp;
}


int main()
{
    int a[]= {1,99,2,88,3,77,4,66};
    int n=sizeof(a)/4;
    for(int i=0; i<=n-1; i++)
          BuildHeap(a,i,n);
    for(int i=n-1; i>=1; i--)
    {
        swap(a[i],a[0]);
        MaxHeapSort(a,0,i);
    }
    cout << a[0] ;
    for(int i=1; i<n; i++) cout << " " << a[i];
    cout <<endl;
    return 0;
}

 

6、歸並排序

歸並的意思就是兩個或兩個以上的有序表組合成一個新的有序表。整個歸並排序需要進行【lgn取上限】次，總的時間復雜度為O(nlgn)。與快速排序相比，歸並排序的最大特點是：它是一種穩定的排序方法。

#include <iostream>
using  namespace std;

void Merge(int *a, int s, int m, int t)
{
    int *b=new int[10];
    int i=s, j=m+1, num=0;
    while(i<=m&&j<=t)
    {
        if(a[i]<=a[j]) b[num++]=a[i], i++;
        else b[num++]=a[j],j++;
    }
    while(i<=m) b[num++]=a[i], i++;
    while(j<=t) b[num++]=a[j], j++;
    for(int i=s; i<=t; i++) a[i]=b[i-s];
    delete[] b;
}

void MergeSort(int *a, int s, int t)
{
    if(a==NULL) return ;
    if(s<t)
    {
        int mid=(s+t)/2;
        MergeSort(a,s,mid);
        MergeSort(a,mid+1,t);
        Merge(a,s,mid,t);
    }
}


int main()
{
    int a[]= {1,99,2,88,3,77,4,66};
    int n=sizeof(a)/4;
    MergeSort(a,0,n-1);
    cout << a[0] ;
    for(int i=1; i<n; i++) cout << " " << a[i];
    cout <<endl;
    return 0;
}

 

7、希爾排序

很多人都說希爾排序是插入排序的一種改進，我看了半天也沒看明白這句話。

希爾排序就是利用無空位的跳躍值gap進行跳躍排序，如果n為8，為gap的取值則為8  4  2  1， gap=gap/2，gap初始值為n/2。

對於每個gap值，都要從后往前掃一遍（以gap值大小跳躍比較），即i，i-gap，i-2*gap……。注意：只限在相鄰兩個掃到的數比較。

時間復雜度：O（nlog（n*n））。

#include <iostream>
using  namespace std;

void ShellSort(int *a, int n)
{
    for(int gap=n/2; gap>0; gap/=2)
        for(int i=gap; i<n; i++)
            for(int j=i-gap; j>=0; j-=gap)
                if(a[j]>a[j+gap]) swap(a[j],a[j+gap]);
}

int main()
{
    int a[]= {1,99,2,88,3,77,4,66,123,321,58,324,127,428};
    int n=sizeof(a)/4;
    ShellSort(a,n);
    cout << a[0];
    for(int i=1; i<n; i++) cout << " " << a[i];
    cout << endl;
    return 0;
}

 

8、二叉樹排序 

二叉樹的性質：對於每個節點，它的左孩子的鍵值一定比它小，右孩子的鍵值一定比它大。

二叉樹排序簡單點說就是先隨便設置一個根節點，然后將其他數一個一個插入到樹中，權值小於此節點則往左走，大於往右走，一直找到合適的位置建立自己新的節點位置。

#include <iostream>
#include <cstring>
#include <sstream>
#include <algorithm>
using  namespace std;

struct Node
{
    int key;
    Node *l, *r;
    Node(){ l=NULL; r=NULL;}
};

Node* Insert(Node *rt, int key)
{
    if(rt==NULL)
    {
        Node *rt=new Node();
        rt->key=key;
        return rt;
    }
    if(key<rt->key) rt->l=Insert(rt->l,key);
    else rt->r=Insert(rt->r,key);
    return rt;
}

void Printf(Node *rt)
{
    if(rt->l!=NULL) Printf(rt->l);
    cout << rt->key << " ";
    if(rt->r!=NULL) Printf(rt->r);
}

int main()
{
    int a[]= {1,99,2,88,3,77,4,66,123,321,58,324,127,428};
    int n=sizeof(a)/4;
    Node *root=new Node();
    root->key=a[0];
    for(int i=1; i<n; i++)
    {
        Insert(root,a[i]);
    }
    Printf(root);
    cout << endl;
    return 0;
}

 

9、基數排序

   基數是一種不穩定的排序，它的時間復雜度為O（k*n），k表示最大數的位數，所以當一個序列中有一個很大很大的數時，它排序所花費的時間是非常高昂的。

   基數排序的原理是一位一位來排序：先按個位大小排序，再按十位大小排序，接着百位……，一直排到最大位數停止。

  比如這樣一個數列排序: 342 ，58， 576， 356

第一次排序(個位):

3 4 2

5 7 6

3 5 6

0 5 8

第二次排序(十位):

3 4 2

3 5 6

0 5 8

5 7 6

第三次排序(百位):

0 5 8

3 4 2

3 5 6

5 7 6

結果: 58 342 356 576。

#include <iostream>
#include <cstring>
#include <sstream>
#include <algorithm>
using  namespace std;

int maxdigit(int *a, int n) //返回數組中最大數的位數
{
    int maxx=0;
    for(int i=0; i<n; i++)
    {
        stringstream sa;
        sa<<a[i];
        string s=sa.str();
        maxx=max(maxx,int(s.size()));
    }
    return maxx;
}

void BaseSort(int *a, int n)
{
    int *count=new int[10];
    int *tmp=new int[n];
    int m=maxdigit(a,n);
    int base=1;
    for(int i=1; i<=m; i++)
    {
        for(int j=0; j<10; j++) count[j]=0;
        for(int j=0; j<n; j++)
        {
            int k=a[j]/base%10;
            count[k]++;
        }
        for(int j=1; j<10; j++)
                count[j]+=count[j-1];
        for(int j=n-1; j>=0; j--)
        {
            int k=a[j]/base%10;
            count[k]--;
            tmp[  count[k] ]=a[j];
        }
        for(int j=0; j<n; j++)  a[j]=tmp[j];
        base*=10;
    }
    delete[] count;
    delete[] tmp;
}

int main()
{
    int a[]= {1,99,2,88,3,77,4,66,123,321,58,324,127,428};
    int n=sizeof(a)/4;
    BaseSort(a,n);
    cout << a[0] ;
    for(int i=1; i<n; i++) cout << " " << a[i];
    cout <<endl;
    return 0;
}