排序总结一【常见的七种比较排序】

1冒泡排序：

void Bubble(int *A,int n)//冒泡算法的简单实现
{
    for(int i=0;i<n-1;i++)
    {
        for(int j=0;j<n-i-1;j++)
        {
            if(A[j]>A[j+1])
            {
                int temp=A[j];
                A[j]=A[j+1];
                A[j+1]=temp;
            }
        }
    }
}

改进后的冒泡排序1，增加标示位

void Bubble_1(int *A,int n)//改进后的冒泡算法，增加标示位
{
    bool pos=false;
    for(int i=0;i<n-1;i++)
    {
        pos=true;
        for(int j=0;j<n-i-1;j++)
        {
            if(A[j]>A[j+1])
            {
                int temp=A[j];
                A[j]=A[j+1];
                A[j+1]=temp;
                pos=false;
            }
        }
        if(pos) return;
    }
}

2选择排序：

void Select(int *A,int n)//简单选择排序
{
    int min;
    for(int j=0;j<n-1;j++)
    {    
        min=j;
        for(int i=j+1;i<n;i++)
        {
        if(A[min]>A[i])
            min=i;
        }
        int temp=A[min];
        A[min]=A[j];
        A[j]=temp;
    }
}

改进的双向选择排序

void Select_1(int *A,int n)//双向选择排序
{
    int min,max;
    for(int j=0;j<(n-1)/2;j++)
    {
        min=j;
        max=n-j-1;
        for(int i=j+1;i<n-j;i++)
        {
            if(A[min]>A[i])
                min=i;
            if(A[max]<A[i])
                max=i;
        }
        int temp=A[min];
        A[min]=A[j];
        A[j]=temp;
        temp=A[max];
        A[max]=A[n-j-1];
        A[n-j-1]=temp;
    }
}

3插入排序

void Insert(int *A,int n)//直接插入算法
{
    int temp,count;
    if(n<2)return;
    for(int i=1;i<n;i++)
    {
        temp=A[i];
        count=i-1;
        while(count>=0&&A[count]>temp)
        {
            A[count+1]=A[count];
            count--;
        }
        A[count+1]=temp;        
    }
}

4希尔排序（改进的插入排序）：

void ShellSort(int *A,int n)//带有步长选择的插入排序
{
    for(int div=n/2;div>=1;div/=2)
    {
        for(int i=div;i<n;i++)
        {
            for(int j=i;j-div>=0&&A[j]<A[j-div]&&j>=0;j-=div)
/*主要看这里，与其说是插入排序，不如说是有步长选择的冒泡排序，
并不是说它不对，只是不好直观理解。*/
            {
                int temp=A[j];
                A[j]=A[j-div];
                A[j-div]=temp;
            }
        }        
    }
}

void ShellSort_1(int *A,int n)//利用插入排序的模型，直观的写法。
{
    for(int div=n/2;div>=1;div/=2)
    {
        for(int i=div;i<n;i++)
        {
            int temp,count;
            temp=A[i];
            count=i-div;
            while(count>=0&&A[count]>temp)
            {
                A[count+div]=A[count];
                count-=div;
            }
            A[count+div]=temp;
        }
    }
}

可以将可变步长单独写成一个函数

void ShellInsert(int *A,int n,int div)
{
        for(int i=div;i<n;i++)
        {
            int temp,count;
            temp=A[i];
            count=i-div;
            while(count>=0&&A[count]>temp)
            {
                A[count+div]=A[count];
                count-=div;
            }
            A[count+div]=temp;
        }
}

 5归并排序：

归并排序在《算法导论》里是最先接触的，也是最为基础的用来理解递归的一种算法，具有O(nlogn)的时间复杂度和O(n)的空间复杂度。 

void MergeSort(int *A,int n)
{
    int *B=new int [n];
    MergeSort(A,B,0,n-1);
    delete []B;
}
void MergeSort(int A[],int B[],int start,int end)
{
    if(start<end)
    {
        int mid=(start+end)/2;
        MergeSort(A,B,start,mid);
        MergeSort(A,B,mid+1,end);
        Merge(A,B,start,mid,end);
    }    
}
void Merge(int A[],int B[],int start,int mid,int end)
{
    int i=start,j=start,k=mid+1;
    while(i!=mid+1&&k!=end+1)
    {
        B[j]=(A[i]<A[k])?A[i++]:A[k++];
        j++;
    }
    while(i!=mid+1)
    {
        B[j]=A[i];
        j++,i++;
    }
    while(k!=end+1)
    {
        B[j]=A[k];
        j++,k++;
    }
    for(i=start;i<=end;i++)
        A[i]=B[i];
}

6快速排序：

void QuickSort(int *A,int n)
{
    QuickSort(A,0,n-1);
}
void QuickSort(int *A,int low,int high)
{
    if(low<high){
    int r=Partition(A,low,high);
    QuickSort(A,low,r-1);
    QuickSort(A,r+1,high);
    }
}
int Partition(int *A,int low,int high)
{
    int key=A[low];
    while(low<high)
    {
        while(low<high&&A[high]>=key)--high;
        A[low]=A[high];
        while(low<high&&A[low]<=key)++low;
        A[high]=A[low];
    }
    A[low]=key;
    return low;
}

7堆排序：

堆排序在做很多题的时候会很常用，要掌握好。

void HeapSort(int *A,int n)//堆排序
{
        int i;
    //length/2-1是最后一个非叶节点
    for(i=n/2-1;i>=0;--i)
        HeapAdjust(A,i,n);
    for(i=n-1;i>0;--i)
    {
        int temp=A[0];
        A[0]=A[i];
        A[i]=temp;
        HeapAdjust(A,0,i);
    }
}
void HeapAdjust(int *A,int i,int length)//调整堆
{
    int nChild;
    int nTemp;
    for(;2*i+1<length;i=nChild)
    {
        nChild=2*i+1;
        if(nChild<length-1&&A[nChild+1]>A[nChild]) nChild++;
        if(A[i]<A[nChild])
        {
            nTemp=A[i];
            A[i]=A[nChild];
            A[nChild]=nTemp;
        }
        else break;
    }        
}

http://blog.csdn.net/hguisu/article/details/7776068