排序算法(还需补充)

/************
十大排序算法
***********/

#include<iostream>
#include<ctime>
using namespace std;

typedef int T;

void swap(T &x,T &y)
{
    T temp;
    temp=x;
    x=y;
    y=temp;
}
//1,冒泡  原地稳定 o(n^2)
void bubble(T *a, int n)
{
    for(int i=0;i<n-1;i++)
        for(int j=0;j<n-1-i;j++)
        {
            if(a[j]>a[j+1])
                swap(a[j],a[j+1]);
        }
}

void improvebubble(T *a, int n)
{
    bool over=true;//作指示，若有一次没交换就结束
    for(int i=0;i<n-1&&over;i++)
    {
        over =false;
        for(int j=0;j<n-1-i;j++)
            if(a[j]>a[j+1])
            {
                swap(a[j],a[j+1]);
                over=true;
            }
    }
}
//2,插排 原地稳定 o(T)=1+2+3+..+n-1=o(n^2)
void insert1(T *a,int n)
{
    for(int i=1;i<n;i++)
    {
        T temp=a[i];
        int j;
        for(j=i-1;j>=0;j--)//和前面抽出来有序的比较
        {
            if(a[j]<=temp)
                break;
            a[j+1]=a[j];
        }
        a[j]=temp;
    }
}

int findpos(T *a,int n, T key)
{
    int high=n-1,low=0;
    while(low<=high)//***这里要有等号，不然high=low(即排查到只剩一个数时)就不判断直接排在前面了
    {
        int mid=(high+low)/2;
        if(key>=a[mid]) //如果相等，定位到其后面，保证稳定排序
            low=mid+1;
        else if (key<a[mid])
            high=mid-1;
    }
    
    return low;
}
void insert2(T *a,int n)
{
    for(int i=1;i<n;i++)
    {
        T temp=a[i];
        int pos=findpos(a,i,temp);
        for(int j=i-1;j>=pos;j--)
        {
            a[j+1]=a[j];
        }
        a[pos]=temp;
        cout<<pos<<endl;
        for(int i=0;i<n;i++)
            cout<<a[i];
        cout<<endl;
    }
}


//3,选择排序 原地不稳定，一次选一个最小的， o(n^2)
void select(T *a,int n)
{
    for(int i=0;i<n-1;i++)
    {
        T min=a[i];
        int k=i;//重要一定要让k=i
        for(int j=i+1;j<n;j++)
        {
            if(min>a[j])//找最小的
            {
                min=a[j];
                k=j;
            }
        }
        if(i!=k)//重要
            swap(a[i],a[k]);//不稳定，比如a[i]不是最小的，它与最小发生交换，打乱了它自己的位置

    }
}
//4.归并排序 非原地稳定 o(nlogn), 需要开辟o(n)的空间
//分治法，每次一分为二，最后将俩部分合并排序
void MergeSort(T *a,int f,int r,int mid)
{
    int i=f,j=mid+1;
    int m=mid,n=r;
    int k=0;
    T *temp=new T[r-f+1];//非原地排序，用来合并数组

    while(i<=m && j<=n)
    {
        if(a[i]<=a[j])//这里等号可保证稳定
            temp[k++]=a[i++];
        else
            temp[k++]=a[j++];
    }
    while(i<=m)
        temp[k++]=a[i++];
    while(j<=n)
        temp[k++]=a[j++];
    for(i=0;i<k;i++)//数组a局部有序
        a[f+i]=temp[i];

    delete [] temp;
}

void Merge(T *a,int f,int r)
{
    if(f<r)
    {
        int mid=(f+r)/2;
        Merge(a,f,mid);
        Merge(a,mid+1,r);
        MergeSort(a,f,r,mid);
    }
}
void merge(T *a, int n)
{
    Merge(a,0,n-1);    
}

//5.快排，原地不稳定 o(nlogn)
void Quick(T *a,int f,int r)
{
    if(f>=r)
        return;
    int i=f,j=r;
    T temp=a[f];//第一个坑
    while(i<j)
    {
        while(temp<=a[j] && i<j)//有可能越界
            j--;
        if(i<j)//如果俩者相遇,即跑到挖的坑那了
            a[i++]=a[j];//后面的小的数填前面的坑
        while(temp>a[i] && i<j)
            i++;
        if(i<j)
            a[j--]=a[i];//用前面的大的数填后面的坑
    }
    a[i]=temp;//最后一坑
    Quick(a,f,i);
    Quick(a,i+1,r);
}
void quick(T*a,int n)
{
    Quick(a,0,n-1);
}

//6.计数排序
//只能是整数(或字符)排序，而且要求分布比较均匀，非原地稳定  
//好处是o(n)线性复杂度，方便序列去重操作
void count(T *a,int n)
{
    T max=a[0],min=a[0];
    int i;
    for(i=0;i<n;i++)//找到序列最小值，以确定桶大小
    {
        if(max<a[i])
            max=a[i];
        if(min>a[i])
            min=a[i];
    }
    int len=max-min+1;
    T* C=new T[len];//记录每个数出现的次数
    for(i=0;i<len;i++)
        C[i]=0;
    for(i=0;i<n;i++)
        C[a[i]-min]+=1;
    for(i=1;i<len;i++)
        C[i]+=C[i-1];

    T *R=new T[n];//
    for(i=n-1;i>=0;i--)//倒着来取可保证稳定排序，后面的还排在后面
    {
        T temp=a[i];
        int pos=C[temp-min];
        R[pos-1]=temp;//注意这的减一.C统计的的是个数，R是从0开始存储的
        C[temp-min]--;
    }

    for(i=0;i<n;i++)
        a[i]=R[i];

    delete [] C;
    delete [] R;
}
//7,希尔排序 分组排序 原地不稳定 
//数组基本有序的情况下更好
void shell1(T *a, int n)
{
    for(int gap=n/2;gap>0;gap/=2) //log n
        for(int i=gap;i<n;i++)//gap=1就是insertSort  o(n/gap)
            for(int j=i-gap;j>=0 && a[j]>a[j+gap];j-=gap) 
                swap(a[j+gap],a[j]);//或者可以先后推找到位置，最后填进去
}

void shell2(T *a,int n)//??不理解 o(nlogn)
{
    int d=n;
    while(d>1)
    {
        d=(d+1)/2;
        for(int i=0;i<n-d;i++)
            if(a[i+d]<a[i])
                swap(a[i+d],a[i]);
    }
}


//8，堆排序 大根堆，向下调整 o(nlogn) 原地不稳定 适合处理大文件
void shiftdown(T *a,int n,int i)//
{
    int t,flag=0;
    while(2*i+1<n && flag==0)//以0为根节点，左右孩子是2i+1,2i+2
    {
        if(a[i]<a[2*i+1])
            t=2*i+1;
        else t=i;
        if(2*i+2<n)//n是节点数，从1开始计的，而i是从0开始计的
            if(a[t]<a[2*i+2])
                t=2*i+2;
        if(t!=i)
        {
            swap(a[i],a[t]);
            i=t;//继续往下调整
        }
        else flag=1;
    }
}
        
void createMaxHeap(T *a,int n)//建立大根堆，o(n/2)
{
    for(int i=n/2;i>=0;i--)//父节点向下调整
        shiftdown(a,n,i);
}

void heapsort(T *a, int n)
{
    createMaxHeap(a,n);
    int k=n-1;
    while(k>0)
    {
        swap(a[k],a[0]);
        k--;
        shiftdown(a,k,0);//o(logk)
    }
}

int main()
{
    const int n=15;
    int a[n]={4,6,5,3,2,1,4,5,6,7,2,8,9,3,1};
    shell2(a,n);
    for(int i=0;i<n;i++)
        cout<<a[i];
    cout<<endl;
    return 0;
}