各种排序的原理

冒泡排序（bubble_sort）：

1.每次只比较相邻的元素，每一趟比较下来后可以确定一个元素的最终位置

2.重复以上的操作

最好的时间复杂度为O(n),最坏的为O(n^2);

void bubble_sort(int Array[],int n){
    for(int i=0;i<n;i++){
        for(int j=0;j<n-i-1;j++){
            if(Array[j]>Array[j+1]){
                int tmp=Array[j];
                Array[j]=Array[j+1];
                Array[j+1]=tmp;
            }
        }
    }
}

选择排序(selection_sort)

每次选择待排序的数列中的最大(小)值放在已经排好的序列的最后

时间复杂度为O(n^2) 

 

void selection_sort(int Array[],int n){
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            if(Array[j]>Array[i]){
                int tmp=Array[j];
                Array[j]=Array[i];
                Array[i]=tmp;
            }
        }
    }
}

计数排序（counting_sort）

计数排序的思想就是对于每个输入x,确定小于x的元素的个数，有了这一信息就可以把x直接放到它在最终输出数组中的位置；

时间复杂度为O(N+K) n为数据的个数k为数据的范围

void counting_sort(int a[],int b[],int n,int k){
    for(int i=0;i<=k;i++)
        c[i]=0;
    for(int i=0;i<n;i++)
        c[a[i]]++;
    for(int i=1;i<=k;i++)
        c[i]+=c[i-1];
    for(int i=n-1;i>=0;i--){
            c[a[i]]--;
            b[c[a[i]]]=a[i];
    }
}

<strong><span style="font-size:18px;">快速排序（quick_sort）</span></strong>

类似于冒泡排序，每次选定一个key值（通常选第一个），然后将比它小的都放在它的前面 ，比它小的都放在它的后面，比它大的都放在它的后面；

时间复杂度为O(n*logn)

(1)设置两个变量i,j，排序开始的时候：i=0，j=n-1

(2)以第一个数据作为关键数据赋值给key，即key=a[0]

(3)从j开始向前搜索，即由后开始向前搜索(j=j-1),找到第一个小于key的值a[j],并与a[i]交换

(4)从i开始向后搜索，即由前向后搜索(i=i+1),找到第一个大于key的值a[i],与a[j]交换

(5)重复(3)(4)(5)步，直到i=j;

void quick_sort(int Array[],int s,int e){
    int key=Array[s];
    int i=s,j=e;
    if(i>=j) return;
    while(i<j){
        while(i<j&&key<=Array[j])
            j--;
        Array[i]=Array[j];
        while(i<j&&key>=Array[i])
             i++;
        Array[j]=Array[i];
    }
    Array[j]=key;
    quick_sort(Array,s,j-1);
    quick_sort(Array,j+1,e);
}

归并排序(merge_sort)

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子

序列是有序的。然后再把有序子序列合并为整体有序序列。归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针达到序列尾，将另一序列剩下的所有元素直接复制到合并序列尾

时间复杂度为O(n*logn)

 

int Array[30],tmp[60];
void merge(int low,int mid,int high)
{
    int i=low,j=mid+1,k=low;
    while(i<=mid&&j<=high)
    {
        //此处为排序顺序的关键，用小于表示从小到大排序
        if(Array[i]<=Array[j]) tmp[k++]=Array[i++];
        else                   tmp[k++]=Array[j++];
    }
    while(i<=mid)  tmp[k++]=Array[i++];
    while(j<=high) tmp[k++]=Array[j++];
    for(i=low;i<=high;i++)   //写回原数组
        Array[i]=tmp[i];
}

/**全部排序的调用为mergeSort(0,n-1) */
void mergeSort(int a,int b)
{
    if(a<b)
    {
         int mid=(a+b)/2;
         mergeSort(a,mid);
         mergeSort(mid+1,b);
         merge(a,mid,b);
    }
}