排序算法的一点总结

#include <string>
#include <list>
#include <vector>
#include <deque>
#include <iomanip>
#include <iostream>

void display(int *a,int n)
{//n为数组个数
    for(int i=0;i<n;++i)
    {
        cout <<setw(3)<< a[i]<<"#";
    }
    cout << endl;
}
void InsertSort(int *a,int n)
{//直接插入排序，n为数组个数
    int i,j,k;
    for(i=1;i<n;++i)
    {
        for(j=i-1,k=a[i];j>=0&&k<a[j];--j)
        {
            a[j+1]=a[j];
        }
        a[j+1]=k;
//         display(a,16);
//         system("pause");
    }
}
void ShellSort(int *a,int n)
{//直接插入排序的改进版，n为数组个数
    int d,i,j,m,k;
    d=8;//增量
    while(d>0)
    {
        m=0;
        while(m<d)//分成d个组后对每个组进行直接插入排序
        {
            for(i=m+d;i<n;i+=d)//这里等价于普通插入算法的i=1;当然你写i=m其实也一样，
            {                    //在内部for循环会判断出界的。
                k=a[i];
                for(j=i-d;j>=0&&k<a[j];j-=d)
                {
                    a[j+d]=a[j];
                }
                a[j+d]=k;
            }
            ++m;//是插入算法的操作对象为下个组
        }
        d/=2;
    }
}
void Bubble1Sort(int *a,int n)
{//冒泡排序，n为数组个数
    int i,j,t;
    for(i=1;i<n;++i)//做n-1趟冒泡处理
    {
        for(j=0;j<n-i;++j)
        {
            if(a[j]>a[j+1])
            {
                t=a[j+1];
                a[j+1]=a[j];
                a[j]=t;
            }
        }
        display(a,n);
        system("pause");
    }
}
void BubbleSort(int* a,int n)//n为数组个数
{//改进思想：在每一躺比较中，当比较结束后，如果发现从某个
//位置t开始，不再进行交换，说明从a[t+1]到a[n-1]已经排序完成了，从而下一躺比较
//只要进行到位置t即可。
    
    int i,t,border;
    border=n-1;
    while (border>0)
    {
        t=0;
        for (i=0;i<border;++i)//这里表明a[border+1]到a[n-1]都不用排序了
        {                       //i最大值为i=border-1;由于if（a[i]>[i+1])    
            if (a[i]>a[i+1])  //所以初始化为border=n-1，不然会在第一躺的时候
            {                  //出现读取超界
                t=a[i];
                a[i]=a[i+1];
                a[i+1]=t;
                t=i;//不断更新边界值
            }
        }
        border=t;
        display(a,n);
    }
    //在我给定的a[N]中，BubbleSort只需要冒泡9次就排序完毕了，而Bubble1Sort
    //不管初始数据怎样有序无序，都需要冒泡N-1次才退出，所以还是这个智能
}
void QuickSort(int* a,int m,int n) 
{//这里的m,n是代表索引能够取到的值；
    if(m>=n) //递归出口
        return;
    int i,j,k,t;
    i=m;j=n+1;
    k=a[m];
    while(i<j)
    {
        i++;
        while(k>a[i])
            ++i;
        j--;
        while(k<a[j])
            --j;
        if(i<j)
        {
            t=a[i];
            a[i]=a[j];
            a[j]=t;
        }
    }
    t=a[j];
    a[j]=a[m];
    a[m]=t;
    QuickSort(a,m,j-1);
    QuickSort(a,j+1,n);
}
void BubbleUpDownSort(int* a,int n)//n为数组个数
{//交替冒泡排序算法
//先冒泡，再下沉，再冒泡，反复交替，直到两个边界相交，说明排序结束
//一般情况下会由于单纯的冒泡，特殊？我下面给了另外一个有规律的数组，得15次才行
    int bu,bd,i,k,t,j;
    bu=n-1;bd=0;i=0;
    while (bu>bd)
    {
        if(0==i)
        {
            t=0;
            for(j=0;j<bu;++j)
            {
                if (a[j]>a[j+1])
                {
                    k=a[j];
                    a[j]=a[j+1];
                    a[j+1]=k;
                    t=j;
                }
            }
            bu=t;i=1;
            display(a,n);
        }
        else
        {
            t=0;
            for(j=n-1;j>bd;--j)
            {
                if (a[j]<a[j-1])
                {
                    k=a[j];
                    a[j]=a[j-1];
                    a[j-1]=k;
                    t=j;
                }
            }
            bd=t;i=0;
            display(a,n);
        }
    }

}
void SelectSort(int* a,int n)//n为数组个数
{//直接选择排序算法：核心思想是第i次操作选择第i小的记录放在第i个位置上
    int k,i,j,t;
    for(i=1;i<n;i++)
    {
        k=i-1;
        for (j=i;j<n;++j)
            if(a[k]>a[j])
                k=j;
        t=a[k];
        a[k]=a[i-1];
        a[i-1]=t;
    }
}
void Restore(int* a,int mm,int n)
{//重建树根为a[m]的二叉树，使之满足堆的特性。a[m]的左右子树是堆，且
//a[m]为根的树的任意节点的编号均不大于n。m,n都为索引可取值
//这里编号为索引号，也是完全二叉树的编号，由0开始
//如果a[i]是根,则a[2i+1]是它的左儿子，a[2i+2]是右儿子，当然是存在的条件下
    int j,k,t;
    j=mm;
    while(j<=(n+1)/2-1)// (n+1)/2-1是有子节点的父节点的最大编号
    {
        if(2*j+1<n && a[2*j+1]<a[2*j+2])//如果2*j+1<n则说明一定有右儿子
            k=j+j+2;
        else 
            k=j+j+1;
        if(a[k]>a[j])
        {//其实下面j=m想当于递归重建上面被交换的堆，使之保持堆的性质
            t=a[k];a[k]=a[j];a[j]=t;j=k;
        }
        else
            j=n;//出口,也可直接break;
    }
}
void HeapSort(int* a,int n)
{//n为数组个数
    int i,t;
    for(i=n/2-1;i>=0;--i)
    {//初始建堆，从有子节点的父节点的最大编号开始，依次递减，利用Restore()
        Restore(a,i,n-1);
    }
    for(i=n-1;i>=0;--i)//开始堆排序了
    { 
        t=a[0];
        a[0]=a[i];
        a[i]=t;
        Restore(a,0,i-1);
    }
}
const int N=16;
const int M=10;
int a[N]={7,2,9,1,16,4,15,5,10,6,3,8,10,12,14,13};
int m[M]={26,5,77,1,61,11,59,15,48,19};
//int a[N]={16,15,14,13,12,11,10,9,1,2,3,4,5,6,7,8};
int main()
{

    display(a,N);
//    ShellSort(a,N);
//    BubbleSort(a,N);
//    BubbleUpDownSort(a,N);
//    QuickSort(a,0,N-1);
//     SelectSort(a,N);  
    HeapSort(a,N);
    display(a,N);

    system("pause");
    return 0;
}