十种排序算法

1.冒泡排序

适合情况

小数据排序

代码实现

void sort(int* a){			//正向排序
    for(int i=0;i<a.size();i++){
        bool x=True;
        for(int j=0;j<a.size()-i-1;j++){
            if(a[j]>a[j+1]){
                swap(a[j],a[j+1]);
                x=False;
            }
        }
        if(x)
            break;
    }
}

2.选择排序

把每次最小的放在第一个

适合情况

小数据排序,且优于冒泡排序

代码实现

void sort(int* a){
    for(int i=0;i<a.size();i++){
        int mini = i;
        int min_num = a[i];
        for(int j=i+1;j<a.size();j++){
            if(a[j]<min_num){
                min_num = a[j];
                mini = j;
            }   
        }
        swap(a[mini],a[i]);
    }
}

3.插入排序

适合的情况

快排的扩充

代码实现

void sort(int *a){
    for(int i=1;i<a.size();i++){
        for(int j=i;j>0;j--){
            if(a[j]<a[j-1])
				swap(a[j],a[j-1]);
        }
    }
        
}

4.归并排序

空间占用太大

适用场景

在数据量比较大的时候也有较为出色的表现（效率上），但是，其空间复杂度O(n)使得在数据量特别大的时候（例如，1千万数据）几乎不可接受。而且，考虑到有的机器内存本身就比较小，因此，采用归并排序一定要注意。

代码实现

void sort1(int *a){
    int[] b =new int(a.size());
    sort2(*a,b,0,a.size());
}
void sort2(int *a,int *b,int le,int ri){
    while(le<ri){
        int mid = ( le + ri ) / 2;
        sort2(a,b,le,mid);
        sort2(a,b,mid+1,ri);
        sort3(a,b,le,mid,ri);
    }
}
void sort3(int *a,int *b,int le,int mid,int ri){
    int l1=le;
    int l2=mid;
    int k=le;
    while(l1<=mid&&l2<=ri){
        b[k++]=a[l1]>a[l2]?a[12++]:a[l1++];
    }
    while(l1<=mid){
        b[k++]=a[l1++];
    }
    while(l2<=ri){
        b[k++]=a[l2++];
    }
    while(le<=ri){
        a[le]=b[le++];
    }
}

5.快速排序

适用情况

快速排序在大多数情况下都是适用的，尤其在数据量大的时候性能优越性更加明显。但是在必要的时候，需要考虑下优化以提高其在最坏情况下的性能。

代码实现

void sort1(int *a){
    sort(a,0,a.size());
}
void sort2(int *a,int le,int ri){
    while(le<ri){
        int x = sort3(a,le,ri);
        sort2(a,le,x-1);
        sort2(a,x+1,ri);
    }
}
int sort3(int *a,int le,int ri){
    int x =a[le];
    while(le<ri){
        while(le<ri&&a[ri]<=x)ri--;
        a[le]=a[ri];
        while(le<ri&&a[le]>=x)ri++
        a[ri]=a[le];
    }
    a[le]=x;
    return le;
}

6.堆排序

适用情况

堆排序在建立堆和调整堆的过程中会产生比较大的开销，在元素少的时候并不适用。但是，在元素比较多的情况下，还是不错的一个选择。尤其是在解决诸如“前n大的数”一类问题时，几乎是首选算法。

代码实现


void sort1(int *a,int k){
    while(k-->0){
        for(int i =(k-1)/2;i>=0;i--){
        sort2(a,i,k);
		}
        swap(a[0],a[k]);
    }
}
void sort2(int *a,int i,int k){
    for(int j = 0;j<2;j++){
        if(2*i+1+j<=k&&a[2*i+1+j]>a[i])
            swap(a[2*i+1+j],a[i]);
    }
}

7.希尔排序

适用场景

Shell排序虽然快，但是毕竟是插入排序，其数量级并没有后起之秀–快速排序O(n㏒n)快。在大量数据面前，Shell排序不是一个好的算法。但是，中小型规模的数据完全可以使用它。

代码实现

void sort(int *a,int len){
    for(int i=len/2;i>0;i--){
        for(int j = 0;j<len-i;j++){
            for(int k=0;k<len-i-j-1;k++){
                if(k+i<len&&a[k]>a[k+i])
                    swap(a[k],a[k+i]);
            }
        }
    }
}

下面是一些常见的增量序列。
- 第一种增量是最初Donald Shell提出的增量，即折半降低直到1。据研究，使用希尔增量，其时间复杂度还是O(n2)。

第二种增量Hibbard：{1, 3, …, 2k-1}。该增量序列的时间复杂度大约是O(n1.5)。

第三种增量Sedgewick增量：(1, 5, 19, 41, 109,…)，其生成序列或者是94i - 92i + 1或者是4i - 3*2i + 1。