排序算法

冒泡

交换相邻的点使得最小的点排到最前,同时后面的点一定程度上也排序。

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

void Bubble(int *list,int length)
{
    bool flag=true;
    for(int i=0;i<=length-1&&flag;i++)
    {
        flag=false;
        for(int j=length-1;j>=i+1;j--)
        {
            if(list[j]<list[j-1])
            {
                int temp=list[j];
                list[j]=list[j-1];
                list[j-1]=temp;
                flag=true;
            }
        }
    }
}

简单选择

查找最小的点,把它放到最前面。

void SelectSort(int * list ,int length)
{
    for(int i=0;i<length-1;i++)
    {
        int min=i;
        for(int j=i+1;j<length;j++)
        {
            if(list[j]<list[min])
            {
                min=j;
            }
        }
        if(i!=min)
        {
            int temp=list[min];
            list[min]=list[i];
            list[i]=temp;
        }
    }

}

直接插入

将第i+1个点插入到已排好序的前i个点中。

void InsertSort(int* list ,int length)
{
    for(int i=1;i<length;i++)//已经排好前i个数,处理第i+1个即下标i的
    {
        int j=i-1;//前i个中的最后一个的下标
        int tempi=list[i];
        for(;j>=0&&tempi<list[j];j--)
        {
            list[j+1]=list[j];
        }
        list[j+1]=tempi;
    }

}

希尔

其实有点类似直接插入，是分成好几组进行的。增量序列为dlta[k]=2^t-k+1-1(0<=k<=t<=log2(n+1))。

第一层do while循环是increment逐次减一，直到increment为1

第二层for循环是比较i和i+increment项，i从头到尾

第三层for循环是为了移动，将比第i+increment项大的都向后移

void ShellSort(int*list,int length)
{
    int increment=length/3+1;
    do
    {
        increment=increment/3+1;
        for(int i=0;i<=length-increment-1;++i)
        {
            int temp=list[i+increment];
            int j=i;
            for(;j>=0&&temp<list[j];j-=increment)
            {
                list[j+increment]=list[j];
            }
            list[j+increment]=temp;
        }
    }while(increment>1);
}

堆排序

先构建最大堆，即先将子树变成最大堆，交换1号和最后一个，再将去掉最后一个的序列调整成最大堆

void heapcore(int *list,int s,int m)
{
    int temp=list[s];
    int j=2*s;
    for(;j<=m;j*=2)
    {
        if(j<m&&list[j]<list[j+1])
            j++;
        if(temp>=list[j])
            break;
        list[j/2]=list[j];
        list[j]=temp;
    }
}
void HeapSort(int*list ,int length)
{
    for(int i=(length-1)/2;i>=1;--i)
    {
        heapcore(list,i,length-1);
    }
    for(int i=length-1;i>=2;--i)
    {
        int temp=list[1];
        list[1]=list[i];
        list[i]=temp;
        heapcore(list,1,i-1);
    }
}

快速

先随机选择一个数，将小于它的放在左边，大于的放在右边。返回该数的位置，然后处理左边序列，右边序列其中放置其他数的方法是，设置一个small标志，从start开始，遇到比轴小的就交换i和small位置的数，small加1

int partition(int *list ,int start,int end)
{
    int idex=rand()%(end-start+1)+start;
    int small=start;
    int key=list[idex];
    list[idex]=list[end];
    list[end]=key;
    for(int i=start;i<end;i++)
    {
        if(list[i]<key)
        {
            int temp=list[small];
            list[small]=list[i];
            list[i]=temp;
            small++;
        }

    }
    int temp=list[small];
    list[small]=list[end];
    list[end]=temp;
    return small;
}
void QSort(int*list,int start,int end)
{
    int id=partition(list ,start,end);
    if(id>start)
        QSort(list,start,id-1);
    if(id<end)
        QSort(list,id+1,end);
}
void QuickSort(int*list,int length)
{
    QSort(list,0,length-1);
}

归并

先两个两个的，再四个四个的，后八个八个的排。。。

//排s1~s2-1（有序）,s2~end（有序）两段，排好放在temp
void Merge(int *list,int *temp,int s1,int s2,int end )
{
    int i=s1;
    int j=s2;
    int k=s1;
    while(i<=s2-1&&j<=end)
    {
        if(list[i]<list[j])
        {
            temp[k]=list[i];
            i++;
            k++;
        }
        else
        {
            temp[k]=list[j];
            j++;
            k++;    
        }
    }
    if(i<=s2-1)
    {
        while(i<=s2-1)
        {
            temp[k]=list[i];
            i++;
            k++;
        }
    }
    if(j<=end)
    {
        while(j<=end)
        {
            temp[k]=list[j];
            j++;
            k++;
        }
    }
}
//从第0个开始，相邻两个k个合并，即0~k-1，k~2k-1合并，2k~3k-1,3k~4k-1合并。。。
void MSort(int*list,int *temp,int k,int length)
{
    int i=0;
    //i是第一个k个的第一个i+2k-1是第二个k个的最后一个，要保证在长度范围内
    for(;i+2*k-1<=length-1;i=i+2*k)
    {
        Merge(list,temp,i,i+k,i+2*k-1);
    }
    //剩下的不足2k个，可能>k&&<2k或者<=k
    //i+k-1是第二个k个的第一个，说明存在第二个k个，需要合并
    if(i+k-1<=length-1)
    {
        Merge(list,temp,i,i+k,length-1);
    }
    //不足k个，不用合并，直接复制
    else
    {
        for(int j=i;j<=length-1;j++)
        temp[j]=list[i];
    }
}
void MergeSort(int*list,int length)
{
    int *temp=new int[length];
    int k=1;
    while(k<length)
    {
    //这样做主要是为了将temp合并到list里面
        MSort(list,temp,k,length);
        k*=2;
        MSort(temp,list,k,length);
        k*=2;
    }
    delete[] temp;
}

 

int main()
{
    int a[1000];
    int i=0;
    int c;
    while(cin>>c)
    {
        a[i]=c;
        i++;        
        if(cin.get()=='\n')
        break;
    }
    //Bubble(a,i);
    //SelectSort(a,i);
    //InsertSort(a,i);
    //ShellSort(a,i);
    //HeapSort(a,i);
    //QuickSort(a,i);
    MergeSort(a,i);
    for(int j=0;j<i;j++)
    {
        cout<<a[j]<<" ";
    }
}