题目：若需要在O（nlogn）（以2为底）的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方法是：
A、快速排序       B、堆排序            C、归并排序  D、直接插入排序

首先咱们来看一下这个表，稳定排序的有直接插入排序、冒泡排序、归并排序和基数排序。
直接插入排序：
最好的情况下：正序有序(从小到大)，这样只需要比较n次，不需要移动。因此时间复杂度为O(n) 
最坏的情况下：逆序有序,这样每一个元素就需要比较n次，共有n个元素，因此实际复杂度为O(n^-2) 
平均情况下：O(n^-2)。

冒泡排序：说白了就是交换排序。

基本思想：通过无序区中相邻记录关键字间的比较和位置的交换,使关键字最小的记录如气泡一般逐渐往上“漂浮”直至“水面”。

最好情况下：正序有序，则只需要比较n次。故，为O(n) 
最坏情况下:  逆序有序，则需要比较(n-1)+(n-2)+……+1，故，为O(N*N)

基数排序：

思想：它是一种非比较排序。它是根据位的高低进行排序的，也就是先按个位排序，然后依据十位排序……以此类推。
时间复杂度：

分配需要O(n),收集为O(r),其中r为分配后链表的个数，以r=10为例，则有0～9这样10个链表来将原来的序列分类。而d，也就是位数(如最大的数是1234，位数是4，则d=4)，即"分配-收集"的趟数。因此时间复杂度为O(d*(n+r))。
适用情况：
如果有一个序列，知道数的范围(比如1～1000)，用快速排序或者堆排序，需要O(N*logN)，但是如果采用基数排序，则可以达到O(4*(n+10))=O(n)的时间复杂度。算是这种情况下排序最快的！！

归并排序：

思想：多次将两个或两个以上的有序表合并成一个新的有序表。 

最好的情况下：一趟归并需要n次，总共需要logN次，因此为O(N*logN)
最坏的情况下，接近于平均情况下，为O(N*logN)

注意：对长度为n的文件，需进行logN 趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。

<span style="font-size:18px;">#include<stdio.h>
#include<stdlib.h>
   
typedef int RecType;//定义要排序元素类型为整形  
void Merge(RecType *R,int low,int m,int high)  
{  
    //将两个有序的子文件R[low..m)和R[m+1..high]归并成一个有序的子文件R[low..high]  
    int i=low,j=m+1,p=0;                //置初始值  
    RecType *R1;                        //R1是局部向量  
    R1=(RecType *)malloc((high-low+1)*sizeof(RecType));  
    if(!R1)  
    {  
        return;                         //申请空间失败  
    }  
  
    while(i<=m&&j<=high)                //两子文件非空时取其小者输出到R1[p]上  
    {  
        R1[p++]=(R[i]<=R[j])?R[i++]:R[j++];  
    }  
  
    while(i<=m)                         //若第1个子文件非空，复制剩余记录到R1中  
    {  
        R1[p++]=R[i++];  
    }  
    while(j<=high)                      //若第2个子文件非空，复制剩余记录到R1中  
    {  
        R1[p++]=R[j++];  
    }  
  
    for(p=0,i=low;i<=high;p++,i++)  
    {  
        R[i]=R1[p];                     //归并完成后将结果复制回R[low..high]  
    }  
}  
  
void MergeSort(RecType R[],int low,int high)  
{     
    //用分治法对R[low..high]进行二路归并排序  
    int mid;  
    if(low<high)  
    {   //区间长度大于1   
        mid=(low+high)/2;               //分解  
        MergeSort(R,low,mid);           //递归地对R[low..mid]排序  
        MergeSort(R,mid+1,high);        //递归地对R[mid+1..high]排序  
        Merge(R,low,mid,high);          //组合，将两个有序区归并为一个有序区  
    }  
}  
int main()  
{  
	int low=0,high=9;                   //初始化low和high的值  
    int a[10]={20,8,9,38,65,90,73,108,13,22}; //这里对10个元素进行排序  

    printf("归并排序前: ");  
    for(int i=low;i<=high;i++)  
    {  
        printf("%d ",a[i]);             //输出结果  
    }  
    printf("\n");  
  
    MergeSort(a,low,high);  
  
    printf("归并排序后的结果:");  
    for( i=low;i<=high;i++)  
    {  
        printf("%d ",a[i]);             //输出结果  
    }  
    printf("\n");
	return 0;
} </span>

各种排序算法对比：

大家要举一反三，自己敲代码实现，才能理会其中的精髓。