各种排序算法（2）

5归并排序

思路就是无限递归对半分一直到1，1可以看成排序好的（也无所谓排序），然后回退到上层时候排序好的左半部分和右半部分依次比大小拷贝到新申请的数组中，然后再用对应的的下标拷贝回原来的位置，复杂度为o（nlogn）。缺点就是空间复杂度为o（n），所以相比快速排序弱爆了。但在外部文件排序中貌似有应用。

代码如下：

[java] view plain copy

1. <span style="font-size:12px;"><span style="font-size:14px;">//归并排序  
2.     public void mergeSort(T[] t,Comparator<T> c){  
3.         mergeSort(t,0,t.length-1,c);  
4.     }  
5.       
6.     private void mergeSort(T[] t,int low,int high,Comparator<T> c){  
7.         if(low<high){//分割到一为止，  
8.             int middle = (low+high)/2;  
9.             mergeSort(t,low,middle,c);  
10.             mergeSort(t,middle+1,high,c);  
11.             //单个元素不需要排序，因此排序过程也在if语句里面  
12.             T[] temp = (T[])new Object[high-low+1];  
13.             int a = 0;//temp 的下标  
14.             int lowIndex = low;//low到middle的索引，  
15.             int highStart = middle+1;  
16.               
17.             while((lowIndex<=middle)&&(high>=highStart)){//排序好的分割2列都有值  
18.                   
19.                 if(c.compare(t[lowIndex], t[highStart])<=0){  
20.                     temp[a++] = t[lowIndex];  
21.                     lowIndex++;  
22.                 }else{  
23.                     temp[a++] = t[highStart];  
24.                     highStart++;  
25.                 }  
26.             }  
27.             while(lowIndex<=middle){//索引低的部分还有剩余项  
28.                 temp[a++] = t[lowIndex];  
29.                 lowIndex++;  
30.             }  
31.             while(high>=highStart){//索引高的部分还有剩余项  
32.                 temp[a++] = t[highStart];  
33.                 highStart++;  
34.             }  
35.             //重置temp的索引并拷贝回原数组  
36.             for(a=0;a<temp.length;a++){  
37.                 t[low++] = temp[a];  
38.                   
39.             }  
40.               
41.         </span>   
42.         }</span>  

6 快速排序

思路是：找到一个支点，然后根据支点把比支点大的元素放在右边，比支点小的元素放在左边，将支点左右两个子数组递归进入下一层一直到子数组长度为1为止。复杂度也是o（nlogn）

对于支点的选择，最普通的情况为选第一个元素，暂时没有证明怎样选取支点复杂度最小，改进一下是比较第一个、中间一个、最后一个元素取中间大小的作为支点。复杂度比直接选取第一个稍好。当支点选取第一个元素时，如果数组为已经排序好的，快速排序会退化到平方阶的复杂度。

代码中的一些小优化：

            1  将比较的3个元素最小的放在0处（这个本来就该在左边），最大的放中间，支点放在最右边（支点不用在中间位置比较自己）。

            2  支点左右分割数组的代码中，与支点相等的数一定也要停下来，这样在递归过程中不会越界，带来的副产品是迭代变量自增自减一定也要写在循环中，不然就是死循环，具体见代码。

代码如下：

[java] view plain copy

1. <span style="font-size:12px;"><span style="font-size:12px;">//快速排序</span>  
2.     public void quickSort(T[] t,Comparator<T> c){  
3.         quickSort(t,0,t.length-1,c);  
4.     }  
5.       
6.     private void quickSort(T[] t,int low,int high,Comparator<T> c){  
7.       
8.         if(low<high){//一个数则不用排序  
9.             int middle = (low+high)/2;  
10.             T temp;//交换值的临时变量  
11.             //三个if确定分割点并将分割点放在最后  
12.             if(c.compare(t[low], t[middle])>0){  
13.                 temp = t[low];t[low] = t[middle];t[middle] = temp;   
14.             }  
15.             if(c.compare(t[low], t[high])>0){  
16.                 temp = t[low];t[low] = t[high];t[high] = temp;  
17.             }  
18.             if(c.compare(t[middle], t[high])<0){  
19.                 temp = t[middle];t[middle] = t[high];t[high] = temp;  
20.             }  
21.             int lowIndex = low;  
22.             int highIndex = high;  
23.             /** 
24.              * 循环内只能放小于大于不能放等于，这样2个下标移动的时候才肯定会 
25.              * 在最小和最大处停下来，而带来的副产品是下标的自增自减一定要放 
26.              * 在循环内，不然会造成循环。 
27.              */  
28.             while(true){//等也要停下来防止越界  
29.                 while(c.compare(t[++lowIndex], t[high])<0)//lowIndex先开始因此  
30.                                                     //循环break后互换用lowIndex  
31.                     ;  
32.                 while(c.compare(t[--highIndex], t[high])>0)//自增自减放下面是死循环  
33.                     ;                                      //加等号相等依然执行会越界  
34.                 if(lowIndex>=highIndex)  
35.                     break;  
36.                 temp=t[lowIndex];t[lowIndex]=t[highIndex];t[highIndex]=temp;  
37.             }  
38.             temp=t[lowIndex];t[lowIndex]=t[high];t[high]=temp;  
39.               
40.               
41.             quickSort(t,low,lowIndex-1,c);  
42.           
43.             quickSort(t,lowIndex+1,high,c);  
44.         }  
45.           
46.     }</span>  

快速排序与归并排序在时间复杂度上，虽然减少了比较的次数，但实际上由于递归的影响，对于少量数据的排序不占任何优势，只有在大数据量的下，递归的影响才会被减少的大量比较所消除。

因此实际上在对于归并和快速排序，递归可以增加个返回条件，在数据量小于个较小数的时候，直接使用冒泡等排序算法优化。

后续见       各种排序算法（3）