关于几种排序的个人整理及分析

编程中的排序算法多的真是不能再多了。

也是今天突发奇想，忽然打算整理出一些常用的，较为简单的几种排序算法。（以下程序都是从小到大排序）

1.冒泡排序（Bubblesort）

这是最为简单也是初学者接触最多的一种排序方法。不断的比较，交换。复杂度O（n^2）

void BubbleSort(int a[],int Asize)
{
    int i,j,temp;
    for(i=0;i<Asize;i++){
        for(j=i;j<Asize;j++){
            if(a[j]<a[i])
                swap(a[j],a[i]);
        }
    }
}

2.选择排序（Selectionsort）

从冒泡中可以发现其实其中总会有些多余的交换，因为当交换的数并不是剩余数中最小的时候，还需要继续往下找到那个最小的数，并且继续交换，因此也就产生了选择排序，先遍历一遍数组，找到剩余数据中的最小值并记录下标，然后再进行交换，避免了不必要的交换，但是复杂度并没有降低，还是没什么实质性的改变O（n^2）

void SelectionSort(int a[],int Asize)
{
    int i,j,minindex,temp;
    for(i=0; i<Asize-1; i++)
    {
        minindex=i;
        for(j=i+1; j<Asize; j++)
        {
            if(a[minindex]>a[j])
                minindex=j;
        }
        if(i!=minindex)    
       swap(a[minindex],a[i]);   
    }
}

3.插入排序（Insertsort）

插入排序也是通过遍历数组，同时将当前数插入到当前位置之前的合适位置。如现在已经排成了（1，3，5）接下来是4，则将当前数保存下来，并且将先前的比当前数大的数向后移动一位，然后将当前数赋值给最后位置。移动插入完成后既是（1，3，4，5），相比先前的排序方式，没有点对点的的交换，但是多了很多移位赋值的工作，效率也不高。复杂度是O（n^2）

void InsertSort(int a[],int Asize)
{
    int i,j,temp;
    for(i=1;i<Asize;i++){
        if(a[i]<a[i-1]){
            temp=a[i];
            for(j=i-1;j>=0&&a[j]>temp;j--)
                a[j+1]=a[j];
            a[j+1]=temp;
        }
    }
}

4.鸽巢排序

相比上述几种方法，鸽巢排序的方法是另一种思路。不难理解，就是开一个足够大的数组，去记录数据次数，然后遍历开的数组。但是当n比较大的时候，开不出这么大的数组。复杂度是O（n），对于数据量较小的排序相对来说已经是非常快的了。（以下例子程序数据最大为255）

void PigeonholeSort(int a[], int Asize)
{
    int b[256] = {0};
    int i,k,j = 0;
    for(i=0; i<Asize; i++)
        b[a[i]]++;
    for(i=0; i<256; i++)
        for(k=0; k<b[i]; k++)
            a[j++] = i;
}

5.希尔排序

希尔排序其实是插入排序的升级版。首先，插入排序是对每个待排序的数，向后遍历对比判断是否往前插入。因此复杂度较高，然而希尔排序先将数据分组，然后不断的二分步长。直到步长为1。

void ShellSort(int a[],int n)
{
    int i,j,gap;
    for(gap=n/2; gap>=1; gap/=2)//希尔排序步长暂定从n/2开始，不一定是最快的
    {
        for(i=gap; i<n; i++)//直接从一个步长之后的元素开始比较
        {
            for(j=i; j>=0&&a[j]<a[j-gap]; j-=gap)//跨度是一个步长，是指是不断交换将小的放在前面，本质就是小型的一个插入排序
            {
                int temp=a[j];
                a[j]=a[j-gap];
                a[j-gap]=temp;
            }
        }
    }
}

6.归并排序

归并排序之前先要理解什么是归并。把两个排好序的数组，合并成一个数组是相对容易的。只需要开一个容器，不断比较两个合并数组的头，然后谁小，谁进容器，当两个数组元素都用过了之后，就得到了归并好的数组。那么要归并总要先二分把。

归并排序就是这样比较独特的一种排序，思想也是二分。先是将所有的数据二分，其中不断调用递归二分，一直到子数组长度为1，，然后不断合并。

void Merge(int a[],int left,int mid,int right,int c[])//归并函数，末端将容器内的数据重新移回排序数组中
{
    int n,m,i,j,k;
    k=0;
    i=left;
    n=mid;//左半边
    j=mid+1;
    m=right;//右半边
    while(i<=n&&j<=m)
    {
        if(a[i]<a[j])
            c[k++]=a[i++];
        else
            c[k++]=a[j++];
    }
    while(i<=n)
        c[k++]=a[i++];
    while(j<=m)
        c[k++]=a[j++];//到此是merge完成，所有元素装在c中
    for(i=0; i<k; i++)//因为是对a排序，因此重新赋值回去
        a[left+i]=c[i];
}
void MergeSort(int a[],int left,int right)//将数据不断二分，直到都分成一个数然后归并
{
    if(right>left)
    {
        int mid=(left+right)/2;
        MergeSort(a,left,mid);//左半边分
        MergeSort(a,mid+1,right);//右半边分
        Merge(a,left,mid,right,temp);//外部定义temp作为merge用的容器
    }
}

7.堆排序

堆排序是选择排序的升级版，选择排序是对每个数据都向后遍历，比对数据大小，然后选出最大的，然后两数交换。

堆排序中的难点就是如何看待堆，如何将数组看成二叉树。以及不断调整。

最容易的是理解调整。既是将父亲与自己的左右孩子中较大的那个比较（新手难点：父节点下标*2是左孩子的下标，再+1就是右孩子），然后交换调整数据，然后不断递归往上继续构造。（升序排序，需要构造最大堆；降序排序，需要构造最小堆）

然后是先处理非叶子节点（新手难点：n/2大致就是非叶子节点的位置），向下搜索（每次比较父亲下的两个孩子，对应下标是*2与*2+1）确保叶子中不存在最大值，越大的数越靠近上边，左边。然后再从右下角开始，将树顶的最大值放到右下角，然后再从0-当前位置，重新调整树，同理找最大值，然后重复交换。

void adjust(int a[],int st,int ed)
{
    int temp,left,right,MaxNumindex;
    MaxNumindex=st;
    left=st*2;
    right=left+1;
    if(left<ed&&a[left]>a[st])
        MaxNumindex=left;
    if(right<ed&&a[right]>a[MaxNumindex])
        MaxNumindex=right;
    if(MaxNumindex!=st)
    {
        temp=a[st];
        a[st]=a[MaxNumindex];
        a[MaxNumindex]=temp;

        adjust(a,MaxNumindex,ed);//先前的操作只是完成了一次上换，递归调用不断往上换
    }
}
void HeapSort(int a[],int n)
{
    int temp;
    for(int i=n/2-1; i>=0; i--) //从非叶子节点开始调整，创建最大堆（或者最小堆），本质就是不断的把叶子上的大值往上换
        adjust(a,i,n);
    for(int i=n-1; i>=0; i--)//从叶子开始不断将小值向上放，同时再调整，保证每次都是最大堆
    {
        temp=a[0];
        a[0]=a[i];
        a[i]=temp;
        adjust(a,0,i);
    }
}

8.快速排序
快速排序也是相对独特的一种排序方式。先确定一个基数，以它为基准线（为了代码方便一般都是取第一个数据），然后将数组中比它大的放在右边，比它小的放在右边（看上去很像插入排序，但有点区别）。先将基准线保存，然后从右向左找到第一个小于它的数，覆盖到基准位置，然后从左向右找到第一个大于它的数，然后覆盖在原先找到的比它小的数，然后不断覆盖，最终的一个位置就是基准线（也就是一开始拿来比较的数）的位置。然后再分左右边进行操作，对其左边的数据操作，右边的数据操作。然后直到最终数据长度为1。

void QuickSort(int s[], int l, int r)
{
    if (l<r)
    {
        int i=l, j=r, key=s[l];
        while(i<j)
        {
            while(i<j&&s[j]>=key)// 从右向左找第一个小于x的数
                j--;
             if(i<j)//是否越界
            s[i]=s[j];
            while(i<j&&s[i]<=key)// 从左向右找第一个大于等于x的数
                i++;
             if(i<j)//是否越界
            s[j]=s[i];
        }
        s[i]=key;
        QuickSort(s,l,i-1); // 递归调用
        QuickSort(s,i+1, r);
    }
}

这篇博客第一版仅仅总结总结了4种方法（到鸽巢排序为止），出于个人学习需要，再次完善，补充了4种复杂度为nlog(n)的几种常用的排序方法。个人总结，希望能对大家有帮助作用。

-------------------------------------------------第三版学习-------------------------------

重新复习，又加深了一些排序算法的理解

#include<bits/stdc++.h>
using namespace std;
/*using for print array*/
void printarr(int a[],int n)
{
    for(int i=1; i<=n; i++)
        cout<<a[i]<<" ";
    cout<<endl;
}

/*shell sort*/
void shellsort(int a[],int n)
{
    cout<<"Shell Sort:"<<endl;
    for(int gap=n/2; gap>=1; gap/=2) //set gap
    {
        for(int i=gap+1; i<=n; i++) //modify start from gap+1
        {
            for(int j=i; j>=gap; j-=gap) //change the adjust element until get the proper position
            {
                if(a[j]<a[j-gap])
                    swap(a[j],a[j-gap]);
            }
        }
        cout<<"after gap:"<<gap<<" change:";
        printarr(a,n);
    }
}


/*merge sort*/
/*include two parts:1.separate two parts 2.merge*/
int temp[10];
void merge_arr(int a[],int l,int mid,int r,int b[])
{
    int n,m,i,j,cnt;
    cnt=0;
    i=l;
    n=mid;
    j=mid+1;
    m=r;
    while(i<=n&&j<=m)
    {
        if(a[i]>a[j])
            b[cnt++]=a[j++];
        else b[cnt++]=a[i++];
    }
    while(i<=n)b[cnt++]=a[i++];
    while(j<=m)b[cnt++]=a[j++];
    for(int i=0; i<cnt; i++)a[l+i]=b[i];
}

void mergesort(int a[],int l,int r)
{
    if(r>l)
    {
        int mid = (l+r)/2;
        mergesort(a,l,mid);
        mergesort(a,mid+1,r);
        merge_arr(a,l,mid,r,temp);
    }
}

/*quick sort*/
void quicksort(int a[],int l,int r)
{
    if(l<r)
    {
        int i=l,j=r,key=a[l];
        while(i<j)
        {
            while(i<j&&a[j]>=key)j--;//from right to left find a number smaller than key
            if(j>i)a[i]=a[j];
            while(i<j&&a[i]<=key)i++;//from left to right find a number greater than key
            if(j>i)a[j]=a[i];
        }
        a[i]=key;
        quicksort(a,l,i-1);
        quicksort(a,i+1,r);
    }
}


void adjust(int a[],int st,int n){
    int lchild = st*2;
    int rchild = st*2+1;
    int maxnum_index=st;
    if(st<=n/2){
        if(lchild<=n&&a[lchild]>a[maxnum_index])
            maxnum_index=lchild;
        if(rchild<=n&&a[rchild]>a[maxnum_index])
            maxnum_index=rchild;
        if(maxnum_index!=st){
            swap(a[st],a[maxnum_index]);
            adjust(a,maxnum_index,n);
        }
    }
}

void build_heap(int a[],int n){
    for(int i=n/2;i>=1;i--)
        adjust(a,i,n);
}

/*heap sort*/
/*include two parts: build heap and adjust*/
void heapsort(int a[],int n)
{
    build_heap(a,n);
    for(int i=n;i>=1;i--){
        swap(a[i],a[1]);
        adjust(a,1,i-1);
    }
}

int main()
{
    std::ios::sync_with_stdio(false);
    int n=10,a[11]= {0,10,9,8,7,6,5,4,3,2,1};
    //shellsort(a,n);
    //mergesort(a,1,n);
    //quicksort(a,1,n);
    heapsort(a,n);
    printarr(a,n);
    return 0;
}