所有排序總結（內排序）

花時間把所有的排序重新 寫了一遍。。。。。（應該是認真寫過一遍，學的時候根本就沒寫過）

     寫得時候才發現，理解不深刻。基本上 只是懂怎么做，不懂為什么。

     把我寫得記在這里，以后用得着了回來看看。

     暫時就到這里吧，以后有時間，繼續研究這些東西。在寫出來。

三個O(n²)的算法

選擇排序：

void SelectionSort(int *a,int n)
{
    for(int i=0;i<n;i++)
    {
        int lowindex = i;
        for(int j=i+1;j<n;j++)
           if(a[j]<a[lowindex])lowindex=j;
        swap(&a[i],&a[lowindex]);//選擇，比bubble交換次數少得多。
    }
}

冒泡排序：

void Bubblesort(int *a,int n)
{
    for(int i=0;i<n;i++)
      for(int j=0;j<n-1;j++)
        if(a[j]>a[j+1])swap(&a[j],&a[j+1]);
}

插入排序：

void insertsort(int *a,int n)
{
    int i,j;
    int tmp;
    for(i = 1;i<n;i++)
    {
        tmp = a[i];
        for(j=i;j>0&&tmp<a[j-1];j--)
        {
              a[j] = a[j-1];//從后往前面數
        }
        a[j] = tmp;//     1 2 3 5 6 7 4  ==>   1 2 3 4 5 6 7
    }
}

 

下面幾個高級的算法。。。  有些把我折騰的夠慘。。。DEBUG 幾個小時 才弄出來。  （鄙視自己。。）

希爾排序：

void shellsort(int *a,int n)
{
    int tmp;
    int i,j;
    int gap;//增量
    for(gap=n/2;gap>0;gap/=2)//增量為n/2
    {
        for(i=gap;i<n;i++)
        {
            tmp = a[i];
            for(j =i;j>=gap&&tmp<a[j-gap];j-=gap)//增量交換。
                a[j] = a[j-gap];
            a[j] = tmp;
        }
    }
}

歸並排序：

void merge(int *array,int *tmp,int start,int center,int end)//合並的程序。
{
    int i=0;
    int arrayCount = end - start + 1;
    int s = start;
    int c = center;
    int e = end;         //不損壞原來的變量
    while(s<=c-1&&c<=e)
    {
        if(array[s]<=array[c])
           tmp[i++] = array[s++];
        else if(array[s]>=array[c])
           tmp[i++] = array[c++];
    }
    while(s<=c-1)
        tmp[i++] = array[s++];
    while(c<=end)
        tmp[i++] = array[c++];
    for(i=start;i<arrayCount;i++)
        array[i] = tmp[i-start];
}
void MergeSort(int *a,int *tmp,int start,int end)
{
    int center;
    if(start<end)
    {
        center = (start+end)/2 + 1;//第二個部分的開始
        MergeSort(a,tmp,start,center-1);
        MergeSort(a,tmp,center,end);
        merge(a,tmp,start,center,end);
    }
}

歸並的一個改進。。。。。改進不大   參照某本書上來的

void merge(int *array,int *tmp,int start,int center,int end)//合並的程序。
{
    //第二個子串逆序復制。    不用判斷是否處理完畢
   int i,j,k;
   for(i=start;i<center;i++)tmp[i]=array[i];
   for(j=0;j<end-center+1;j++)tmp[end-j] = array[center+j];
   for(i=start,j=end,k=start;k<=end;k++)
      if(tmp[i]<=tmp[j])array[k] = tmp[i++];
      else  array[k] = tmp[j--];
}//改進的部分

然后就是傳說中的快排了

快速排序 hoare版      參照某博文   july的快速排序分析。

int HoarePartition(int *A,int p,int r)
{
    int i,j,x;
    x = A[p];
    i = p-1;
    j = r+1;
    while(true)
    {
        do
        {
            j--;
        }while(A[j]>x);//找到小於等於的
        do
        {
            i++;
        }while(A[i]<x);//找到大於等於的
        if(i<j)
           swap(&A[i],&A[j]);
        else
           return j;
    }
}
/*      用do   while    的原因            */ 
/*如果data數組有相同元素就可能陷入死循環，比如：
      2 3 4 5 6 2 
  l->|             |<-h

交換l和h單元后重新又回到：
      2 3 4 5 6 2 
  l->|             |<-h

而第一個程序不存在這種情況，因為它總是在l和h調整后比較，也就是l終究會大於等於h。
*/ 
void QuickSort(int *A,int p,int r)
{
    int q;
    if(p<r)
    {
        q = HoarePartition(A,p,r);
        QuickSort(A,p,q);
        QuickSort(A,q+1,r);
    }
}

快速排序Hoare變形版

int HoarePartition_1(int *A,int p,int r)
{
    int i,j,x;
    x = A[p];
    i = p;
    j = r;
    while(i<j)
    {
        while(A[j]>=x&&i<j)j--;
        A[i] = A[j];
        while(A[i]<=x&&i<j)i++;
        A[j] = A[i];
    }
    A[i] = x;
    return i;
}
void QuickSort(int *A,int p,int r)
{
    int q;
    if(p<r)
    {
        q = HoarePartition_1(A,p,r);
        QuickSort(A,p,q-1);
        QuickSort(A,q+1,r);
    }
}

快速排序  算法導論版

int partition(int *A,int p,int r)
{
    int i,j,x;
    x = A[r];
    i = p-1;
    for(j = p;j<r;j++)
    {
        if(A[j]<=x)
        {
            i+=1;
            swap(&A[i],&A[j]);
        } 
    }
    swap(&A[i+1],&A[r]);
    return i+1;
}
void quicksort(int *A,int p,int r)
{
    if (p<r)
    {
        int q = partition(A,p,r);
        quicksort(A,p,q-1);
        quicksort(A,q+1,r);
    }
}

啰嗦一句就是，快排 里面的partition  的返回值一定要搞明白。。。。。

這個幾個快速排序 都是參照 july 的博文來的。。。 感謝他。

 

最后  

堆排序：（莫名其妙 調試了很久。。。。。。）

void buildmaxHeap(int *heap,int num)//建大頂堆   完全二叉樹數組存放
{
    int leftchild,rightchild;
    int maxchild;
    for(int i=num/2-1;i>=0;i--)
    {
        leftchild = 2*i+1;//子節點  根節點 從0開始
        rightchild =2*i+2;
        if(leftchild<num && rightchild>=num)
           maxchild = leftchild;
        else if(leftchild>=num)
           maxchild = i;//不存在這種情況
        else if(rightchild<num)
        {
            if( heap[leftchild]<=heap[rightchild] )
               maxchild = rightchild;
            else if(heap[leftchild]>heap[rightchild])
               maxchild = leftchild;
        }

        if(heap[i]<heap[maxchild])
           swap(&heap[i],&heap[maxchild]);
    }
}
void HeapSort(int *heap,int n)
{
    for(int i=n;i>0;i--)
    {
        buildmaxHeap(heap,i);
        swap(&heap[0],&heap[i-1]);//最大的值交換到最后面
    }
}

 

恩，歸並的遞歸  堆排序   都糾結了較長時間

         有時間，我還要把遞歸好好看一看。。。。。

 

注：這上面的swap和測試的代碼   我就沒貼了