C/C++：各種基本算法實現小結（五）—— 排序算法

各種基本算法實現小結（五）—— 排序算法

（均已測試通過）

 

* 選擇排序 |____簡單選擇排序 |____堆排序 |____歸併排序

* 交換排序 |____冒泡排序 |____快速排序

* 插入排序 |____直接插入排序 |____折半排序 |____希爾排序

* 分配排序 |____箱排序 |____基數排序

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

簡單排序算法

 

1、 冒泡排序

測試環境：VC 6.0 (C)

#include
 <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 11
void input(int num[])
{
    int i;

    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
    printf("/n");
}
void sort(int num[])
{
    int i, j, tmp;
    for(i=1; i<MAX-1; i++)
    {
        printf("bubble.../n");
        for(j=1; j<MAX-i; j++)
        {
            printf("%5d", num[j]);
            if(num[j]>num[j+1])
            {
                tmp=num[j];
                num[j]=num[j+1];
                num[j+1]=tmp;
            }
        }
        printf("%5d/n", num[MAX-i]);

        printf("bubble after.../n");
        for(j=1; j<MAX; j++)
            printf("%5d", num[j]);
        printf("/n");
    }
}
/* bubble sort */
/*
void sort(int num[])
{
    int i, j, tmp;
    for(i=1; i<MAX-1; i++)
    {
        for(j=1; j<MAX-i; j++)
            if(num[j]>num[j+1])
            {
                tmp=num[j];
                num[j]=num[j+1];
                num[j+1]=tmp;
            }
    }
}
*/
void main()
{
    int num[MAX];
    printf("sort before.../n");
    input(num);
    output(num);
    sort(num);
    printf("sort after.../n");
    output(num);
}

運行結果：

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

2、雙向冒泡排序

據說可以提高效率，減少比較次數和交換次數

但仔細分析可得，每次while循環，都for循環比較了兩次

因此每次low和high各減1，總體上比較次數並未減少，兩次for交換也未減少

個人認爲雙向冒泡算法並未有效的減少比較次數和交換次數，但此算法也富含編程思想，值得學習

 

測試環境：VC 6.0 (C)

#include
 <stdio.h>
#include <stdlib.h>
#include <time.h>
#define swap(x, y){int tmp; tmp=x; x=y; y=tmp;}
#define MAX 11
void input(int num[])
{
    int i;

    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
}
void sort(int num[], int low, int high)
{
    int i;

    while(low<high)
    {
        for(i=low; i<high; i++) /* bubble to high */
            if(num[i]>num[i+1])
                swap(num[i], num[i+1]);
        high--;

        for(i=high; i>low; i--)  /* bubble to low */
            if(num[i]<num[i-1])
                swap(num[i], num[i-1]);
        low++;
    }
}
void main()
{
    int num[MAX];
    input(num);

    printf("sort before.../n");
    output(num);

    sort(num, 1, MAX-1);
    printf("sort after.../n");
    output(num);
}

運行結果：

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

3、選擇排序

測試環境：VC 6.0 (C)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 101
void input(int num[])
{
    int i;

    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
    printf("/n");
}
void sort(int num[])
{
    int i, j, k, tmp;
    for(i=1; i<MAX-1; i++)
    {
        k=i;
        for(j=i+1; j<MAX; j++)
            if(num[k]>num[j])
                k=j;
        if(i<k)
        {
            tmp=num[i];
            num[i]=num[k];
            num[k]=tmp;
        }
    }
}
void main()
{
    int num[MAX];
    printf("sort before.../n");
    input(num);
    output(num);
    sort(num);
    printf("sort after.../n");
    output(num);
}

運行結果：

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

 

中級排序算法

向部分已排好序數列插入新值，使整個數列最終都有序

 

1、直接插入排序

測試環境：VC 6.0 (C)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 11
void input(int num[])
{
    int i;

    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
    printf("/n");
}
void sort(int num[])
{
    int i, pos, tmp;
    for(i=2; i<MAX; i++) /* from 2 to sorting */
    {
        pos=i;
        tmp=num[pos];
        while(pos>1 && tmp<num[pos-1])
        {
            num[pos]=num[pos-1];
            pos--;
        }
        num[pos]=tmp;
    }
}
void main()
{
    int num[MAX];
    printf("sort before.../n");
    input(num);
    output(num);
    sort(num);
    printf("sort after.../n");
    output(num);
}

運行結果：

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

2、 折半插入排序

折半插入排序算法是一種穩定的排序算法，比直接插入算法明顯減少了關鍵字之間比較的次數

因此速度比直接插入排序算法快，但記錄移動的次數沒有變，

所以折半插入排序算法的時間複雜度仍然爲O(n^2)，

測試環境：VC 6.0 (C)

#include
 <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 11
void input(int num[])
{
    int i;

    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
    printf("/n");
}
void sort(int num[], int low, int high)
{
    int i, j, mid;
    int l, h;
    for(i=2; i<=high; i++)
    {
        l=low;
        h=i-1;
        num[0]=num[i]; /* save */

        while(l<=h)
        {
            mid=(l+h)/2;
            if(num[0]<num[mid])
                h=mid-1;
            else
                l=mid+1;
        }

        for(j=i; j>l; j--)  /* move */
            num[j]=num[j-1];
        num[l]=num[0];
    }
}
void main()
{
    int num[MAX];

    input(num);

    printf("sort before.../n");
    output(num);
    sort(num, 1, MAX-1);

    printf("sort after.../n");
    output(num);
}

運行結果：

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

3、 2-路插入排序

2-路插入排序：是在折半插入排序的基礎上再次改進，其目的是減少排序過程中記錄移動的次數

測試環境：VC 6.0 (C)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 11
int num2[MAX];
void input(int num[])
{
    int i;

    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
    printf("/n");
}
void bi_insertsort(int num[], int len)
{
    int i, j, pos, head, tail;
    head=tail=1;
    num2[1]=num[1];
    for(i=2; i<=len; i++)
    {
        if(num[i]>num2[1])  /* larger, save to tail */
        {
            for(j=tail; j>1; j--)
            {
                if(num[i]<num2[j])
                    num2[j+1]=num2[j];
                else
                    break;
            }
            num2[j+1]=num[i];
            tail++;
        }
        else    /* smaller, save to head */
        {
            if(head==1)   /* first to end, then to head... */
            {
                num2[len]=num[i];
                head=len;
            }
            else
            {
                for(j=head; j<=len; j++)
                {
                    if(num[i]>num2[j])
                        num2[j-1]=num2[j];
                    else
                        break;
                }
                num2[j-1]=num[i];
                head--;
            }
        }
    }

    pos=1;
    for(i=1; i<=len; i++) /* move back data from num2[] to num[] */
    {
        if(head<=len)
            num[i]=num2[head++];
        else if(pos<=tail)
            num[i]=num2[pos++];
    }
}
int main()
{
    int num[MAX]; /* 1 - len is num, 0->null */
    input(num);
    printf("sort before.../n");
    output(num);

    bi_insertsort(num, MAX-1);
    printf("sort after.../n");
    output(num);

    return 0;
}

運行結果：

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

4、合併插入排序（數組實現）

將兩個有序數組A、B合併成另一個有序的大數組C

 

測試環境：VC 6.0 (C)

#include <stdio.h>
void input_num1(int num[], int n1)
{
    int i;
    for(i=1; i<=n1; i++)
        num[i]=3*(i-1);
    printf("/nnum 1.../n");
    for(i=1; i<=n1; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
}
void input_num2(int num[], int n2)
{
    int i;
    for(i=1; i<=n2; i++)
        num[i]=i;
    printf("/nnum 2.../n");
    for(i=1; i<=n2; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
}
void output_num3(int num1[], int n1, int num2[], int n2, int num3[], int n3)
{
    int pos1, pos2, pos3;
    pos3=pos2=pos1=1;

    while(pos1<=n1 && pos2<=n2)
    {
        if(num1[pos1]<num2[pos2])
            num3[pos3++]=num1[pos1++];
        else
            num3[pos3++]=num2[pos2++];
    }
    while(pos1<=n1)
        num3[pos3++]=num1[pos1++];
    while(pos2<=n2)
        num3[pos3++]=num2[pos2++];
    printf("/n/nnum 3.../n");
    for(pos3=1; pos3<=n3; pos3++)
    {
        printf("%5d", num3[pos3]);
        if(0 == pos3%10)
            printf("/n");
    }
}
void main()
{
    int num1[11];
    int num2[21];
    int num3[31];

    input_num1(num1, 10);
    input_num2(num2, 20);
    output_num3(num1, 10, num2, 20, num3, 30);
}

運行結果：

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

5、合併插入排序（鏈表實現）

將兩個有序鏈表A、B合併成另一個有序的大鏈表C（鏈表單元來自A和B）

 

測試環境：VC 6.0 (C)

#include <stdio.h>
#include <malloc.h>
struct _link
{
    int data;
    struct _link *next;
};
typedef struct _link link, *plink;
plink init_link()
{
    plink p;

    p=(plink)malloc(sizeof(link));
    if(!p) /* if(p == NULL) */
    {
        printf("Error. malloc fail.../n");
        return NULL;
    }
    p->data=-1;
    p->next=NULL;
    return p;
}
plink input_num1(plink plk, int n1)
{
    int i, count;
    plink p, s;

    p=plk;

    for(i=1; i<=n1; i++)
    {
        s=(plink)malloc(sizeof(link));
        if(!s) /* if(p == NULL) */
        {
            printf("Error. malloc fail.../n");
            return NULL;
        }
        s->data=3*(i-1);
        s->next=NULL;
        p->next=s;
        p=p->next;
    }

    count=0;
    s=plk->next;
    while(s)
    {
        count++;
        printf("%5d", s->data);
        s=s->next;
        if(0 == count%10)
            printf("/n");
    }
    printf("/n");
    return plk;
}
plink input_num2(plink plk, int n2)
{
    int i, count;
    plink p, s;

    p=plk;

    for(i=1; i<=n2; i++)
    {
        s=(plink)malloc(sizeof(link));
        if(!s) /* if(p == NULL) */
        {
            printf("Error. malloc fail.../n");
            return NULL;
        }
        s->data=i;
        s->next=NULL;
        p->next=s;
        p=p->next;
    }

    count=0;
    s=plk->next;
    while(s)
    {
        count++;
        printf("%5d", s->data);
        s=s->next;
        if(0 == count%10)
            printf("/n");
    }
    printf("/n");
    return plk;
}
void output_num3(plink plk1, plink plk2, plink plk3)
{
    int count;
    plink p1, p2, p3;
    p1=plk1->next;
    p2=plk2->next;
    p3=plk3;
    while(p1 && p2)
    {
        if(p1->data < p2->data)
        {
            p3->next=p1;
            p3=p3->next;
            p1=p1->next;
        }
        else
        {
            p3->next=p2;
            p3=p3->next;
            p2=p2->next;
        }
    }
    p3->next = p1 ? p1 : p2; /* NOTE: directly link to not NULL address, OK */
    count=0;
    p3=plk3->next;
    while(p3)
    {
        count++;
        printf("%5d", p3->data);
        p3=p3->next;
        if(0 == count%10)
            printf("/n");
    }
    printf("/n");
}
void main()
{
    plink plk1, plk2, plk3;

    plk1=init_link();
    plk2=init_link();
    plk3=init_link();
    printf("num 1.../n");
    plk1=input_num1(plk1, 10);
    printf("num 2.../n");
    plk2=input_num2(plk2, 20);

    printf("num 3.../n");
    output_num3(plk1, plk2, plk3);
}

運行結果：

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

 

高級排序算法

 

 

1、 快速排序

測試環境：VC 6.0 (C)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 21
void input(int num[])
{
    int i;

    srand(time(NULL));
    for(i=0; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
}
void sort(int num[], int low, int high)
{
    int l, h;
    l=low;
    h=high;
    if(low < high)
    {
        num[0]=num[l]; /* num[0] save pivot */

        while(l<h)
        {
            while(l<h && num[h]>=num[0]) h--;
            num[l]=num[h];
            while(l<h && num[l]<=num[0]) l++;
            num[h]=num[l];
        }
        num[l]=num[0];
        sort(num, low, l-1);
        sort(num, l+1, high);
    }
}
void main()
{
    int num[MAX];
    input(num);
    printf("/nsort before.../n");
    output(num);
    sort(num, 1, MAX-1);
    printf("/nsort before.../n");
    output(num);
}

運行結果：

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

2、 希爾排序

說明：本示例僅測試10或11個數的3趟希爾排序

由於希爾排序的增量step至今尚無精準的數學論證，無法給出科學、高效的序列函數

據嚴蔚敏的《數據結構（C語言版）》介紹說：希爾排序的分析是一個複雜的問題，因爲它的時間是所取“增量”序列的函數，這涉及一些數學上尚未解決的難題（P272）.

 

因此，本示例僅是實際問題實際解決的一個特例。

本算法基本思想仍是上述直接排序算法的改進，僅僅步長由1變成了step而已

如果大家想需要增添或減少數組元素個數，請一併修改input（）函數中的step等趟數序列

如果大家對希爾排序算法有更好的改進，或有較好步長的函數和通用模板，希望能拿出來共同學習交流分享，謝謝！

 

測試環境：VC 6.0 (C)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 11   /* num[] */
#define STEP 4   /* jump[] */
void input(int num[], int jump[])
{
    int i;
    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
    for(i=1; i<STEP; i++)
        jump[i]=7-2*i;   /* 1->5; 2->3; 3->1 */
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
}
void sort(int num[], int jump[])
{
    int i, j, pos, step;
    for(i=1; i<STEP; i++)
    {
        step=jump[i];
        for(j=1+step; j<MAX; j++)
        {
            pos=j;
            num[0]=num[pos]; /* save num[j] where (i+step)<j<MAX */
            while(num[0]<num[pos-step])
            {
                num[pos]=num[pos-step];
                pos=pos-step; /* shell: jump step */
            }
            num[pos]=num[0];
        }
    }
}
void main()
{
    int num[MAX];
    int jump[STEP];

    input(num, jump);
    printf("sort before.../n");
    output(num);
    sort(num, jump);

    printf("sort after.../n");
    output(num);
}

運行結果：

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

2、 希爾排序（網摘）

在學習希爾排序算法時，看到網上有如下一段希爾排序代碼，也可以直接運行

但看代碼來真得很費解，感覺變量定義不夠直觀，算法設計也不太簡潔

因此，在最大程度保留源代碼時，僅對變量名和算法邏輯簡單修改

力爭做到變量名清晰，邏輯順暢，達到不用註釋讀者也能看明白

希望對大家學習有點幫助

 

測試環境：VC 6.0 (C)

摘錄原代碼：http://apps.hi.baidu.com/share/detail/5669244（百度空間）

#include <iostream.h>
void ShellSort(int* pData,int Count)
{
   int step[4];
   step[0] = 9;
   step[1] = 5;
   step[2] = 3;
   step[3] = 1;
   int iTemp;
   int k,s,w;
   for(int i=0;i<4;i++)
   {
     k = step[i];
     s = -k;
     for(int j=k;j<Count;j++)
     {
       iTemp = pData[j];
       w = j-k;//求上step個元素的下標
       if(s ==0)
       {
         s = -k;
         s++;
         pData[s] = iTemp;
       }
       while((iTemp<pData[w]) && (w>=0) && (w<=Count))
       {
         pData[w+k] = pData[w];
         w = w-k;
       }
       pData[w+k] = iTemp;
     }
   }
}
void main()
{
   int data[] = {10,9,8,7,6,5,4,3,2,1,-10,-1};
   ShellSort(data,12);
   for (int i=0;i<12;i++)
     cout<<data[i]<<" ";
   cout<<"/n";
}

 

修改後代碼：

#include <iostream.h>
void ShellSort(int* pData,int Count)
{
    int iTemp;
    int steplen, pos;
    int step[4];
    step[0] = 9;
    step[1] = 5;
    step[2] = 3;
    step[3] = 1;

    for(int i=0;i<4;i++)
    {
        steplen = step[i];
        for(int j=0+steplen; j<Count; j++)
        {
            iTemp = pData[j];
            pos=j;
            while(iTemp<pData[pos-steplen] && pos>0)
            {
                pData[pos] = pData[pos-steplen];
                pos=pos-steplen;
            }
            pData[pos] = iTemp;
        }
    }
}
void main()
{
    int data[] = {10,9,8,7,6,5,4,3,2,1,-10,-1};
    cout<<endl<<"sort before..."<<endl;
    for (int i=0;i<12;i++)
        cout<<data[i]<<" ";
    cout<<endl;
    ShellSort(data,12);
    cout<<endl<<"sort before..."<<endl;
    for (i=0;i<12;i++)
        cout<<data[i]<<" ";
    cout<<endl;
}

運行結果：

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

3、 堆排序

測試環境：VC 6.0 (C)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 11
void input(int num[])
{
    int i;

    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
    printf("/n");
}
void heapadjust(int num[], int s, int len) /* build large heap */
{
    int j;
    num[0]=num[s];  /* save temp data */

    for(j=2*s; j<=len; j*=2)
    {
        if(j<len && num[j]<num[j+1]) /* num[j+1] is limited by j<len beyond the border */
            j++;
        if(num[0]>num[j])
            break;
        num[s]=num[j];
        s=j;
    }
    num[s]=num[0];
}
void heapsort(int num[], int len)
{
    int i, tmp;
    for(i=len/2; i>0; i--) /* build heap */
        heapadjust(num, i, len);

    for(i=len; i>1; i--)   /* sort heap */
    {
        tmp=num[1];    /* change largest data to end */
        num[1]=num[i];
        num[i]=tmp;
        heapadjust(num, 1, i-1); /* rebuild large heap for (i-1) data */
    }
}
int main()
{
    int num[MAX]; /* 1 - len is num, 0->null */
    input(num);
    printf("sort before.../n");
    output(num);

    heapsort(num, MAX-1);
    printf("sort after.../n");
    output(num);

    return 0;
}

運行結果：

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

4、 歸併排序

測試環境：VC 6.0 (C)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 11
int num2[MAX]; /* copy array */
void input(int num[])
{
    int i;

    srand((unsigned)time(NULL));
    for(i=1; i<MAX; i++)
        num[i]=rand()%100;
}
void output(int num[])
{
    int i;

    for(i=1; i<MAX; i++)
    {
        printf("%5d", num[i]);
        if(0 == i%10)
            printf("/n");
    }
    printf("/n");
}
void merge(int num[], int low, int mid, int high)
{
    int l, h, i, j;
    l=low;
    h=high;
    for(i=mid+1, j=low; low<=mid && i<=high; j++)
    {
        if(num[low]<num[i])
            num2[j]=num[low++];
        else
            num2[j]=num[i++];
    }
    if(low<=mid)
        for(; j<=high; j++, low++)
            num2[j]=num[low];
    if(i<=high)
        for(; j<=high; j++, i++)
            num2[j]=num[i];
    for(i=l; i<=h; i++)
        num[i]=num2[i];
}
void mergesort(int num[], int low, int high)
{
    int mid;
    if(low==high)
        num2[low]=num[low];
    else
    {
        mid=(low+high)/2;
        mergesort(num, low, mid);     /* to low */
        mergesort(num, mid+1, high);  /* to high */
        merge(num, low, mid, high);   /* recursion */
    }
}
int main()
{
    int num[MAX]; /* 1 - len is num, 0->null */
    input(num);
    printf("sort before.../n");
    output(num);

    mergesort(num, 1, MAX-1);
    printf("sort after.../n");
    output(num);

    return 0;
}

運行結果：

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

排序算法的知識擴展（網摘）

 

內部排序算法的比較和實現
引用網址：http://www.cppblog.com/feosun/archive/2008/10/12/63831.html（直接摘錄，尚未測試）

參考網址：http://sjjp.tjuci.edu.cn/sjjg/DataStructure/DS/web/paixu/paixu8.1.1.1.htm（數據結構）

排序是數據處理中經常使用的一種重要運算,在計算機及其應用系統中,花費在排序上的時間在系統運行時間中佔有很大比重;並且排序本身對推動算法分析的發展 也起很大作用。目前已有上百種排序方法，但尚未有一個最理想的盡如人意的方法，本文介紹常用的如下排序方法的C/C++實現，並對它們進行分析和比較。

 

選擇排序、快速排序、希爾排序、堆排序不是穩定的排序算法，而冒泡排序、插入排序、歸併排序和基數排序是穩定的排序算法。

首先，排序算法的穩定性大家應該都知道，通俗地講就是能保證排序前2個相等的數其在序列的前後位置順序和排序後它們兩個的前後位置順序相同。在簡單形式化一下，如果Ai = Aj, Ai原來在位置前，排序後Ai還是要在Aj位置前。

其次，說一下穩定性的好處。排序算法如果是穩定的，那麼從一個鍵上排序，然後再從另一個鍵上排序，第一個鍵排序的結果可以爲第二個鍵排序所用。基數排序就 是這樣，先按低位排序，逐次按高位排序，低位相同的元素其順序再高位也相同時是不會改變的。另外，如果排序算法穩定，對基於比較的排序算法而言，元素交換 的次數可能會少一些(個人感覺，沒有證實)。

回到主題，現在分析一下常見的排序算法的穩定性，每個都給出簡單的理由。

(1)冒泡排序
        冒泡排序就是把小的元素往前調或者把大的元素往後調。比較是相鄰的兩個元素比較，交換也發生在這兩個元素之間。所以，如果兩個元素相等，我想你是不會再無 聊地把他們倆交換一下的；如果兩個相等的元素沒有相鄰，那麼即使通過前面的兩兩交換把兩個相鄰起來，這時候也不會交換，所以相同元素的前後順序並沒有改 變，所以冒泡排序是一種穩定排序算法。

(2)選擇排序
      選擇排序是給每個位置選擇當前元素最小的，比如給第一個位置選擇最小的，在剩餘元素裏面給第二個元素選擇第二小的，依次類推，直到第n-1個元素，第n個 元素不用選擇了，因爲只剩下它一個最大的元素了。那麼，在一趟選擇，如果當前元素比一個元素小，而該小的元素又出現在一個和當前元素相等的元素後面，那麼 交換後穩定性就被破壞了。比較拗口，舉個例子，序列5 8 5 2 9，我們知道第一遍選擇第1個元素5會和2交換，那麼原序列中2個5的相對前後順序就被破壞了，所以選擇排序不是一個穩定的排序算法。

(3)插入排序
     插入排序是在一個已經有序的小序列的基礎上，一次插入一個元素。當然，剛開始這個有序的小序列只有1個元素，就是第一個元素。比較是從有序序列的末尾開 始，也就是想要插入的元素和已經有序的最大者開始比起，如果比它大則直接插入在其後面，否則一直往前找直到找到它該插入的位置。如果碰見一個和插入元素相 等的，那麼插入元素把想插入的元素放在相等元素的後面。所以，相等元素的前後順序沒有改變，從原無序序列出去的順序就是排好序後的順序，所以插入排序是穩 定的。

(4)快速排序
    快速排序有兩個方向，左邊的i下標一直往右走，當a[i] <= a[center_index]，其中center_index是中樞元素的數組下標，一般取爲數組第0個元素。而右邊的j下標一直往左走，當a[j] > a[center_index]。如果i和j都走不動了，i <= j, 交換a[i]和a[j],重複上面的過程，直到i>j。交換a[j]和a[center_index]，完成一趟快速排序。在中樞元素和a[j]交 換的時候，很有可能把前面的元素的穩定性打亂，比如序列爲 5 3 3 4 3 8 9 10 11，現在中樞元素5和3(第5個元素，下標從1開始計)交換就會把元素3的穩定性打亂，所以快速排序是一個不穩定的排序算法，不穩定發生在中樞元素和 a[j] 交換的時刻。

(5)歸併排序
    歸併排序是把序列遞歸地分成短序列，遞歸出口是短序列只有1個元素(認爲直接有序)或者2個序列(1次比較和交換),然後把各個有序的段序列合併成一個有 序的長序列，不斷合併直到原序列全部排好序。可以發現，在1個或2個元素時，1個元素不會交換，2個元素如果大小相等也沒有人故意交換，這不會破壞穩定 性。那麼，在短的有序序列合併的過程中，穩定是是否受到破壞？沒有，合併過程中我們可以保證如果兩個當前元素相等時，我們把處在前面的序列的元素保存在結 果序列的前面，這樣就保證了穩定性。所以，歸併排序也是穩定的排序算法。

(6)基數排序
   基數排序是按照低位先排序，然後收集；再按照高位排序，然後再收集；依次類推，直到最高位。有時候有些屬性是有優先級順序的，先按低優先級排序，再按高優 先級排序，最後的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。基數排序基於分別排序，分別收集，所以其是穩定的排序算法。

(7)希爾排序(shell)
    希爾排序是按照不同步長對元素進行插入排序，當剛開始元素很無序的時候，步長最大，所以插入排序的元素個數很少，速度很快；當元素基本有序了，步長很小， 插入排序對於有序的序列效率很高。所以，希爾排序的時間複雜度會比o(n^2)好一些。由於多次插入排序，我們知道一次插入排序是穩定的，不會改變相同元 素的相對順序，但在不同的插入排序過程中，相同的元素可能在各自的插入排序中移動，最後其穩定性就會被打亂，所以shell排序是不穩定的。

(8)堆排序
   我們知道堆的結構是節點i的孩子爲2*i和2*i+1節點，大頂堆要求父節點大於等於其2個子節點，小頂堆要求父節點小於等於其2個子節點。在一個長爲n 的序列，堆排序的過程是從第n/2開始和其子節點共3個值選擇最大(大頂堆)或者最小(小頂堆),這3個元素之間的選擇當然不會破壞穩定性。但當爲n /2-1, n/2-2, ...1這些個父節點選擇元素時，就會破壞穩定性。有可能第n/2個父節點交換把後面一個元素交換過去了，而第n/2-1個父節點把後面一個相同的元素沒 有交換，那麼這2個相同的元素之間的穩定性就被破壞了。所以，堆排序不是穩定的排序算法。

/*
   冒泡排序  插入排序 二路插入排序 希爾排序   快速排序 選擇排序 歸併排序  堆排序算法的
   C/C++實現。
   
   作者：feosun

   日期：2008年10月12日

   參考資料：數據結構(C語言版) 清華大學出版社

*/

#include <iostream>
using namespace std;


//交換兩個數的值
void swap(int &a,int &b)
{
    int tmp;
    tmp=a;
    a=b;
    b=tmp;
}

//屏幕輸出數組
void display(int array[],int len)
{
    cout<<"the result is:"<<endl;
    for (int i = 0 ;i < len;i++ )
    {
        cout<<array[i]<<"  ";
    }
    cout<<endl;
}

/*
冒泡排序

算法思想：將被排序的記錄數組R[1..n]垂直排列，每個記錄R[i]看作是重量爲R[i].key的氣泡。
          根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組 R：凡掃描到違反本原則的
          輕氣泡，就使其向上"飄浮"。如此反覆進行，直到最後任何兩個氣泡都是輕者在上，
          重者在下爲止。

時間複雜度 o(n^2)

空間複雜度 o(1)

比較次數 n(n+1)/2
*/
void bubble_sort(int array[],int len)
{
    
    for (int i = len-1 ;i >= 0;i-- )
    {
        for(int j = 0;j < i;j++)
            if(array[j] > array[j+1])
                swap(array[j],array[j+1]);
    }
}

/*
直接插入排序

算法思想：把n個待排序的元素看成爲一個有序表和一個無序表，開始時有序表中只包含一個元
          素，無序表中包含有n-1個元素，排序過程中每次從無序表中取出第一個元素，將它
          插入到有序表中的適當位置，使之成爲新的有序表，重複n-1次可完成排序過程。

時間複雜度 o(n^2)

空間複雜度 o(1)

比較次數 n(n+1)/2
*/
void insert_sort(int array[],int len)
{
    int tmp,i,j;

    for(i = 1;i < len;i++)
    {
        if (array[i] < array[i-1])
        {
            tmp = array[i];
            array[i] = array[i-1];

            //插入到相應位置
            for (j = i-2;j >= 0;j--)
            {
                //往後移
                    if (array[j] > tmp )
                        array[j+1] = array[j];
                    else
                    {
                        array[j+1] = tmp;
                        break;
                    }
            }
            if(j == -1)
            array[j+1] = tmp;
        }
    }
}

/*
2-路插入排序

算法思想：增加一個輔助空間d,把r[1]賦值給d[1]，並將d[1]看成是排好序後處於中間
          位置的記錄。然後從r[2]開始依次插入到d[1]之前或之後的有序序列中。

時間複雜度 o(n^2)

空間複雜度 o(1)

比較次數 n(n+1)/2
*/

void bi_insert_sort(int array[],int len)
{
    int* arr_d = (int *)malloc(sizeof(int) * len);

    arr_d[0] = array[0];
    int head = 0,tail = 0;
    for (int i = 1;i < len; i++ )
    {
        if (array[i] > arr_d[0])
        {
            int j;
            for ( j= tail;j>0;j--)
            {
                if (array[i] < arr_d[j])
                    arr_d[j+1] = arr_d[j];
                else
                    break;
            }
            arr_d[j+1] = array[i];
            tail += 1;
        }

        else
        {
            if (head ==0)
            {
                arr_d[len-1] = array[i];
                head =len-1;
            }
            else
            {
                int j;
                for (j = head;j <= len-1;j++)
                {
                    if (array[i] > arr_d[j])
                        arr_d[j-1] = arr_d[j];
                    else
                        break;
                }
                arr_d[j-1] = array[i];
                head -= 1;
            }
        }

    }

    for (int i = 0;i < len; i++)
    {
        int pos = (i + head );
        if(pos >= len) pos -= len;
        array[i] = arr_d[pos];
    }

    free(arr_d);
}

/*
希爾排序

算法思想：先將整個待排序記錄分割成若干子序列分別進行直接插入排
          序，待整個序列中的記錄基本有序時，再對全體記錄進行一
          次直接插入排序

時間複雜度 o(n^2)

空間複雜度 o(1)

比較次數 ?
*/

void shell_insert(int array[],int d,int len)
{
    int tmp,j;

    for (int i = d;i < len;i++)
    {
        if(array[i] < array[i-d])
        {
            tmp = array[i];
            j = i - d;
            do 
            {
                array[j+d] = array[j];
                j = j - d;
            } while (j >= 0 && tmp < array[j]);

            array[j+d] = tmp; 
        }
    }
}
void shell_sort(int array[],int len)
{
    int inc = len;

    do 
    {
        inc = inc/2;
        shell_insert(array,inc,len);
    } while (inc > 1);
}

/*
快速排序

算法思想：將原問題分解爲若干個規模更小但結構與原問題相似的子問題。遞
          歸地解這些子問題，然後將這些子問題的解組合成爲原問題的解。

時間複雜度 o(nlogn)

空間複雜度 o(logn)

比較次數  ?
*/

int partition(int array[],int low,int high)
{
    int  pivotkey = array[low];

    while (low < high)
    {
        while(low < high && array[high] >= pivotkey)
            --high;
        swap(array[low],array[high]);

        while(low < high && array[low] <= pivotkey)
            ++low;
        swap(array[low],array[high]);
    }

    array[low] = pivotkey;

    return low;
}

void quick_sort(int array[],int low,int high)
{
    if (low < high)
    {
        int pivotloc = partition(array,low,high);
        quick_sort(array,low,pivotloc-1);
        quick_sort(array,pivotloc+1,high);
    }
}

/*
直接選擇排序

算法思想：每一趟在n-i+1個記錄中選取關鍵字最小的記錄作爲有序序列中的第i個記錄

時間複雜度 o(n^2)

空間複雜度 o(1) ?

比較次數  n(n+1)/2
*/

int SelectMinKey(int array[],int iPos,int len)
{
    int ret = 0;

    for (int i = iPos; i < len; i++)
    {
        if (array[ret] > array[i])
        {
            ret = i;
        }
    }
    return ret;
}

void select_sort(int array[],int len)
{
    for (int i = 0; i < len; i++)
    {
        int j = SelectMinKey(array,i,len);
        if (i != j)
        {
            swap(array[i],array[j]);
        }
    }
}

/*
歸併排序

算法思想：設兩個有序的子文件(相當於輸入堆)放在同一向量中相鄰的位置上：R[low..m]，R[m+1..high]，先
          將它們合併到一個局部的暫存向量R1(相當於輸出堆)中，待合併完成後將R1複製回R[low..high]中。

時間複雜度 o(nlogn)

空間複雜度 o(n) 

比較次數  ?
*/

void merge(int array[],int i,int m, int n)
{
    int j,k;

    int iStart = i, iEnd = n;

    int arrayDest[256];

    for ( j = m + 1,k = i; i <= m && j <= n; ++k)
    {
        if (array[i] < array[j])
            arrayDest[k] = array[i++];
        else
            arrayDest[k] = array[j++];
    }

    if (i <= m)
        for (;k <= n; k++,i++)
            arrayDest[k] = array[i];
    if(j <= n)
        for (;k <= n; k++,j++)
            arrayDest[k] = array[j];

    for(j = iStart; j <= iEnd; j++)
        array[j] = arrayDest[j];
}

void merge_sort(int array[],int s,int t)
{
    int m;

    if (s < t) 
    {
        m = (s + t )/2;
        merge_sort(array,s,m);
        merge_sort(array,m+1,t);
        merge(array,s,m,t);
    }
}

/*
堆排序

算法思想：堆排序（Heap Sort）是指利用堆（heaps）這種數據結構來構造的一種排序算法。
          堆是一個近似完全二叉樹結構，並同時滿足堆屬性：即子節點的鍵值或索引總是
          小於（或者大於）它的父節點。
時間複雜度 o(nlogn)
空間複雜度 o(1) 
比較次數  較多
*/

void heap_adjust(int array[],int i,int len)
{
    int rc = array[i];

    for(int j = 2 * i; j <len; j *= 2)
    {
        if(j < len && array[j] < array[j+1]) j++;
        if(rc >= array[j]) break;

        array[i] = array[j]; i = j;
    }
    array[i] = rc;
}

void heap_sort(int array[],int len)
{
    int i;
    for(i = (len-1)/2; i >= 0; i--)
        heap_adjust(array,i,len);
    for(  i = (len-1); i > 0; i--)
    {
        swap(array[0],array[i]);   //彈出最大值，重新對i-1個元素建堆
        heap_adjust(array,0,i-1);
    }
}

int main() {

    int array[] = {45,56,76,234,1,34,23,2,3,55,88,100};

    int len = sizeof(array)/sizeof(int);

    //bubble_sort(array,len);           //冒泡排序

    /*insert_sort(array,len);*/         //插入排序

    /*bi_insert_sort(array,len);*/      //二路插入排序
    
    /*shell_sort(array,len);*/          //希爾排序 

    /*quick_sort(array,0,len-1);*/      //快速排序
    
    /*select_sort(array,len);*/         //選擇排序

    /*merge_sort(array,0,len-1);*/      //歸併排序
    
    heap_sort(array,len);               //堆排序
    display(array,len);

    return 0;
}