算法总结——三大排序（快排，计数排序，归并）

快排：

适用条件：方便...只要数字不是很多

复杂度：O（nlogn）  每一层n复杂度，共logn层

原理：利用一个随机数与最后面一个数交换，那么这个随机数就到了最后一位，然后循环，如果前面的数大于最后一个数，那么把这个数放到前面去，经过一次排序之后，前面的数都是大于最后一个的，然后对1到k和k+1到n进行排序，一层一层地下去

模板：

#include<cstdio>

#include<algorithm>

#include<time.h>

using namespace std;

void Sort(int *a,int l,int r)

{

int k = 0;

int len = l - r;

if(len <= 1) return ;

srand(time(NULL));

int pos = rand()%len;

swap(a[r-1],a[pos+l]);

for(int i = l; i < r; i++){

      if(a[i] >a[r-1]){

           swap(a[i],a[l+k]);

          k++;

      }

}

Sort(a,l,l+k-1);

Sort(a,l+k,r);

}

计数排序

复杂度：O（n+k）

适用条件：正数

原理：计数排序的基本思想是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。例如，如果输入序列中只有17个元素的值小于x的值，则x可以直接存放在输出序列的第18个位置上。当然，如果有多个元素具有相同的值时，我们不能将这些元素放在输出序列的同一个位置上，因此，上述方案还要作适当的修改（来自百度百科）

通俗来说，用a来记录所有的要排序的值，w来记录以该值为下标的值的个数，通过计数，w就变成小于这个数的下标的数有多少个，w[a[i]]也就是小于当前a[i]的数有多少个，也就是确定了位置，用一个数组p来记录这个位置下的这个值，然后小于这个数的其他数的个数就少了一个，那么位置全部确定了直接输出就行

计数排序的一个特点就是要开这个数值一样多的结点，比如7000，那就要开7000个，显然如果数字少并且大的话很不合算，但是多的话计数排序比快排快了六倍。

模板：

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

const int maxn = 222222;

int p[maxn],w[maxn],a[maxn];

void sort(int *a,int n,int mx)

{

    for(int i = 1; i <= mx; i++)

        w[i] = 0;

    for(int i = 1; i <= n; i++)

        w[a[i]]++;

    for(int i = 1; i <= mx; i++)

        w[i] += w[i-1];

    for(int i = n; i >= 1; i--){

        p[w[a[i]]] = a[i];

        w[a[i]]--;

    }

}

int main()

{

    int n,mx = 0;

    while(~scanf("%d",&n)){

        for(int i = 1; i <= n; i++){

            scanf("%d",&a[i]);

          mx = max(mx,a[i]);

        }

        sort(a,n,mx);

        for(int i = 1; i < n; i ++)

            printf("%d ",p[i]);

        printf("%d\n",p[n]);

    }

    return 0;

}

ps：orz，原来叫计数排序，不叫桶排，醉了~~~~~~

归并排序（Merge_Sort)：

适用范围：可以用来求逆序数，在第二部分块比较上就有排序的功能，在这里记录就行，详情看代码注释处，如果数字多的话就使用，毕竟稳定，但所占内存也比较多

复杂度：O（nlogn)  合并O(n) 分成每一小块O（logn）

原理：用了分治思想，要使得所有串都排序好，那么把整块不断的分成小块，直到最后几个数，然后从下往上对于整个序列进行比较排序，用了递归（分治：把大问题分成每一个小问题来解决），也就是这个算法分成两个部分：1.对整个串进行分块 2.对分好块的进行比较排序进行合并

模板：

#include<cstdio>

#include<cstring>

using namespace std;

const int MAX = 222222;

int a[MAX],temp[MAX];

int ans = 0;

void mergesort(int *a,int first,int mid,int last,int *temp)

{

    int i = first, j = mid + 1;

    int k = first ;

    while( i <= mid && j <= last){

        if(a[i] <= a[j])

        temp[k++] = a[i++];

        else {

       // ans += j - k; 逆序数求法，因为a都都是从小到大排好的，如果a[i]>a[j]说明a[i]后面的数都大于a[j]前面的数，那么逆序数就要增加j-k个

        temp[k++] = a[j++];



        }

    }

    while( i <= mid )

        temp[k++] = a[i++];

    while( j <= last)

        temp[k++] = a[j++];

    for(int i = first ; i <= last;i++)

        a[i] = temp[i];

}

void mergearray(int *a,int first,int last,int *temp)

{

    if(first < last){

            int mid = (first + last) >> 1;

            mergearray(a,first,mid,temp);

            mergearray(a,mid+1,last,temp);

            mergesort(a,first,mid,last,temp);

    }

}

int main()

{

    int n;

    scanf("%d",&n);

    for(int i = 1; i <= n ;i++)

    scanf("%d",&a[i]);

    mergearray(a,1,n,temp);

    for(int i = 1; i < n; i++)

        printf("%d ", a[i]);

       printf("%d\n",a[n]);

       printf("%d\n",ans);

    return 0;

}

 

总结：三大排序用的最多的还是快排和归并，毕竟归并可以用来求逆序数，快排方便，计数一般不用吧~~~