所有排序总结（内排序）

花时间把所有的排序重新 写了一遍。。。。。（应该是认真写过一遍，学的时候根本就没写过）

     写得时候才发现，理解不深刻。基本上 只是懂怎么做，不懂为什么。

     把我写得记在这里，以后用得着了回来看看。

     暂时就到这里吧，以后有时间，继续研究这些东西。在写出来。

三个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和测试的代码   我就没贴了