五种经典排序算法的实现（冒泡、归并、快排、堆排序、希尔）

转载自：http://blog.csdn.net/xamhaha/article/details/76034765

#include <iostream>
using namespace std;
void swap(int &d,int& b)
{
    int temp;
    temp=d;
    d=b;
    b=temp;
}
//冒泡排序
void Bubblesort(int arry[],int len)
{
    int i,j;
    for(i=0;i<len-1;i++)
    {
        for(j=len-1;j>i;--j)
        {
            if(arry[j]<arry[j-1])
                swap(arry[j],arry[j-1]);
        }    
    }
}
void Bubble2sort(int *arry,int len)
{
    int i,t;
    int left=1;
    int right=len-1;
    while(left<=right)
    {
        //从左到右找最大
        for(i=left;i<=right;i++)
        {
            if(arry[i]<arry[i-1])
            {
                swap(arry[i],arry[i-1]);
                t=i;
            }
        }
        right=t-1;       
        //从右到左找最小
        for(i=right;i>=left;i--)
        {
            if(arry[i]<arry[i-1])
            {
                swap(arry[i],arry[i-1]);
                t=i;
            }
        }
        left=t+1;      
    }
}
void Bubble3sort(int *arry,int len)
{
    int i;
    bool flag;
    flag=true;
    while(flag)
    {
        flag=false;
        for(i=1;i<len;i++)
        {
            if(arry[i-1]>arry[i])
            {
                swap(arry[i-1],arry[i]);
                flag=true;
            }
        }
    }
}
void Bubble4sort(int *arry,int len)
{
    int i,k,flag;
    flag=len;
    while(flag>0)
    {
        k=flag;
        flag=0;
        for(i=1;i<k;i++)
        {
            if(arry[i-1]>arry[i])
            {
                swap(arry[i-1],arry[i]);
                flag=i;
            }
        }
    }
}
//归并排序
void mergesort(int*,int,int,int*);
void mergearry(int*,int,int,int,int*);
bool Mergesort(int arry[],int len)
{
    int *pTemp=new int[len];
    if(pTemp==NULL)
        return false;
    mergesort(arry,0,len-1,pTemp);
    return true;
}
void mergesort(int arry[],int first,int last,int temp[])
{
    if(first<last)
    {
        int mid=(first+last)/2;
        mergesort(arry,first,mid,temp);
        mergesort(arry,mid+1,last,temp);
        mergearry(arry,first,mid,last,temp);
    }
}
void mergearry(int arry[],int first,int mid,int last,int temp[])
{
    int i=first,j=mid+1;
    int n=mid,m=last;
    int k=0;
    while(i<=n&&j<=m)
    {
        if(arry[i]<arry[j])
            temp[k++]=arry[i++];
        else
            temp[k++]=arry[j++];
    }
    while(i<=n)
        temp[k++]=arry[i++];
    while(j<=m)
        temp[k++]=arry[j++];
    for(i=0;i<k;i++)
    {
        arry[first+i]=temp[i];
    }
}
//快速排序
void Quicksort(int arry[],int left,int right)
{
    if(left<right)
    {
        int i=left,j=right,x=arry[i];
        while(i<j)
        {
            while(i<j && arry[j]>=x)
                j--;
            if(i<j)
                arry[i++]=arry[j];
            while(i<j && arry[i]<x)
                i++;
            if(i<j)
                arry[j--]=arry[i];
        }
        arry[i]=x;
        Quicksort(arry,left,i-1);
        Quicksort(arry,i+1,right);
    }
}
//堆排序（大顶堆、小顶堆）
//从i节点开始调整,len为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2
//调整为大顶堆
void AdjustMaxHeap(int *arry,int i,int len)
{
    int j,temp;
    temp=arry[i];
    j=2*i+1;
    while(j<len)
    {
        if(j+1<len && arry[j+1]>arry[j])
            j++;
        if(arry[j]<=temp)
            break;
        arry[i]=arry[j];
        i=j;
        j=2*i+1;
    }
    arry[i]=temp;
}
//调整为小顶堆
void AdjustMinHeap(int *arry,int i,int len)
{
    int temp,child;
    for(temp=arry[i];2*i+1<=len;i=child)
    {
        child=2*i+1;
        if(child<len && arry[child]>arry[child+1])
            child++;
        if(arry[child]<temp)
            arry[i]=arry[child];
        else
            break;
    }
    arry[i]=temp;
}

void HeapSort(int *arry,int len)
{
    int i;
    for(i=len/2-1;i>=0;i--)
    {
        AdjustMaxHeap(arry,i,len);//arry[]={9 7 8 5 6 0 1 4 2 3}
//        AdjustMinHeap(arry,i,len-1);//arry[]={0 2 1 4 3 8 5 7 9 6}
    }
    for(i=len-1;i>=1;i--)
    {
        swap(arry[i],arry[0]);
        AdjustMaxHeap(arry,0,i);//arry[]={0 1 2 3 4 5 6 7 8 9}
//        AdjustMinHeap(arry,0,i-1);//arry[]={9 8 7 6 5 4 3 2 1 0}
    }
}
//希尔排序
void Shellsort(int *arry,int len)
{
    int i,j,h,temp;
    for(h=len/2;h>0;h=h/2)
    {
        for(i=h;i<len;i++)
        {
            temp=arry[i];
            for(j=i-h;j>=0;j=j-h)
            {
                if(temp<arry[j])
                {
                    arry[j+h]=arry[j];
                }
                else
                    break;
            }
            arry[j+h]=temp;
        }
    }
}

int main()
{
    int k;
    int c[]={5,4,8,2,6,0,1,7,9,3};
    int len=sizeof(c)/sizeof(c[0]);
//    Bubble4sort(c,len);
//    Mergesort(c,len);
//    Quicksort(c,0,len-1);
//    HeapSort(c,len);
    Shellsort(c,len);
    for(k=0;k<len;k++)
        cout<<c[k]<<' ';
    cout<<endl;
    system("pause");
    return 0;
}