排序算法总结及面试题

排序算法总览

排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。内排序有可以分为以下几类：

(1)、插入排序：直接插入排序、二分法插入排序、希尔排序。
(2)、选择排序：简单选择排序、堆排序。
(3)、交换排序：冒泡排序、快速排序。
(4)、归并排序
(5)、线性时间排序：计数排序、基数排序、桶排序

算法复杂度以及稳定性分析

外排序

外排序（External sorting）是指能够处理极大量数据的排序算法。通常来说，外排序处理的数据不能一次装入内存，只能放在读写较慢的外存储器（通常是硬盘）上。外排序通常采用的是一种“排序-归并”的策略。在排序阶段，先读入能放在内存中的数据量，将其排序输出到一个临时文件，依次将待排序数据组织为多个有序的临时文件。然后在归并阶段将这些临时文件组合为一个大的有序文件，也即排序结果。

内排序

插入排序

直接插入排序

基本思想：每步将一个待排序的纪录，按其关键字的大小插入到已经排好序的有序数据中，直到全部插入完为止。

[java]  view plain  copy

1. public static void insertSort(int[] arr){  
2.     if(arr == null || arr.length <= 1) return;   
3.     for(int i=1;i<arr.length ;i++){  
4.         int p=i;  
5.         int temp=arr[p];  
6.         while(p>0&&arr[p-1]>temp){  
7.             arr[p]=arr[p-1];  
8.             p--;  
9.         }  
10.         arr[p]=temp;  
11.     }  
12. }  

特征分析：

1、空间复杂度O(1)。最好时间复杂度O(n)，最坏时间复杂度O(n^2)，平均时间复杂度为O(n^2)。最好情况下（已有序），比较次数n-1，移动次数0，最坏情况，比较次数O(n^2)，移动次数O(n^2)。

2、直接插入排序是稳定的。

使用场景：

适合少量数据的排序，或者数据基本已经有序的情况。

二分插入排序（折半插入）

直接插入排序算法在寻找插入位置是采用线性查找的方式，我们可以采用二分查找来确定插入位置从而减少比较次数。

[java]  view plain  copy

1. public static void binaryInsertSort(int[] arr){  
2.     if(arr == null || arr.length <= 1) return;   
3.     for(int i=1;i<arr.length ;i++){  
4.         int temp=arr[i];  
5.         int start=0,end=i;  
6.         while(start<end){  
7.             int mid=start+(end-start)/2;  
8.             if(arr[mid]<=temp){  
9.                 start=mid+1;  
10.             }else{  
11.                 end=mid;  
12.             }  
13.         }  
14.         int p=i;  
15.         while(p>end){  
16.             arr[p]=arr[p-1];  
17.             p--;  
18.         }  
19.         arr[p]=temp;  
20.     }  
21. }  

特征分析：
1、折半插入排序仅减少了关键字间的比较次数，而记录的移动次数不变。
使用场景：
1、如果元素的比较的操作比较耗时，可以对直接插入排序的性能进行提升。

链表的插入排序

由于链表不具有随机访问特性，因此不适用于折半插入排序，只适用于直接插入排序，每次从已排序数据表头开始查找插入位置。

[java]  view plain  copy

1. public class ListNode{  
2.     private int val;  
3.     private ListNode next;  
4.     public ListNode(int val){  
5.         this.val=val;  
6.     }  
7. }  
8. public static ListNode listInsertSort(ListNode head){  
9.     ListNode myHead=new ListNode(-1);  
10.     ListNode p=head,t,pre,post;  
11.     while(p!=null){  
12.         t=p;  
13.         p=p.next;  
14.         pre=myHead;  
15.         post=myHead.next;  
16.         while(post!=null&&post.val<=t.val){  
17.             pre=pre.next;  
18.             post=post.next;  
19.         }  
20.         t.next=post;  
21.         pre.next=t;  
22.     }  
23.     return myHead.next;  
24. }  

希尔排序

基本思想：
直接插入排序中，如果元素X初始化时所处的位置为i，排序后所处位置为j，那么元素x必须要经过j-i-1(j>=i)次移动。而希尔排序中，我们先取一个小于n的整数d1作为第一个增量，把数据的全部记录分组。所有距离为d1的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量

 di 

  =1( 

 di 

  < 

 di-1 

  …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止（这时候数组已经基本有序）。平均情况下，因为分组的增量>=1，元素X从初始化位置移动到最终位置所需要的次数比原来要小。

[java]  view plain  copy

1. public static void shellSort(int[] arr){  
2.     if(arr == null || arr.length <= 1) return;   
3.     int gap=arr.length/2;  
4.     while(gap>0){  
5.         for(int i=1;i<arr.length ;i++){  
6.             int temp=arr[i];  
7.             int p=i;  
8.             while(p>=gap&&arr[p-gap]>temp){  
9.                 arr[p]=arr[p-gap];  
10.                 p-=gap;  
11.             }  
12.             arr[p]=temp;  
13.         }  
14.         gap/=2;  
15.     }  
16. }  

特征分析：
不需要大量的辅助空间，和归并排序一样容易实现。希尔排序是基于插入排序的一种算法， 在此算法基础之上增加了一个新的特性，提高了效率。希尔排序的时间复杂度与增量序列的选取有关，希尔排序时间复杂度的下界是n*log2n。希尔排序没有快速排序算法快 O(n(logn))，因此中等大小规模表现良好，对规模非常大的数据排序不是最优选择。但是比O(

 n^2 

  )复杂度的算法快得多。并且希尔排序非常容易实现，算法代码短而简单。 此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多，与此同时快速排序在最坏的情况下执行的效率会非常差。专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快，再改成快速排序这样更高级的 排序算法 . 本质上讲， 希尔排序算法 是直接插入排序算法的一种改进，减少了其复制的次数，速度要快很多。 原因是，当n值很大时 数据项 每一趟排序需要的个数很少，但数据项的距离很长。当n值减小时每一趟需要移动的数据增多，此时已经接近于它们排序后的最终位置。 正是这两种情况的结合才使希尔排序效率比 插入排序 高很多。Shell算法的性能与所选取的分组长度序列有很大关系。只对特定的待排序记录序列，可以准确地估算关键词的比较次数和对象移动次数。想要弄清关键词比较次数和记录移动次数与增量选择之间的关系，并给出完整的数学分析，至今仍然是数学难题 。

选择排序

简单选择排序

它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

[java]  view plain  copy

1. public static void simpleSelectSort(int[] arr){  
2.     if(arr==null||arr.length<=1)  
3.         return;  
4.     for(int i=0;i<arr.length;i++){  
5.         int start=i,minIndex=i;  
6.         for(int j=i+1;j<arr.length;j++){  
7.             if(arr[j]<arr[minIndex])  
8.                 minIndex=j;  
9.         }  
10.         int temp=arr[start];arr[start]=arr[minIndex];arr[minIndex]=temp;  
11.     }  
12. }  

特征分析：
1、空间复杂度O(1)，最好/最坏/平均时间复杂度都是O(n^2)，比较次数O(n^2)，移动次数O(n)。
2、选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

堆排序

堆

堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。最小堆通常在构造优先队列时使用。

堆排序

基本思想：

首先通过自底向上的调整堆来建立大根对，然后依次将最大值a[0]与末尾元素交换并调整交换后的堆（大小减1）。

[java]  view plain  copy

1. //调整堆  
2. public static void adjustHeap(int[] arr,int size,int top){  
3.     while(top*2+1<=size-1){  
4.         int change=0;  
5.         if(top*2+1==size-1){//只有左子节点  
6.             change=top*2+1;  
7.             if(arr[top]>=arr[top*2+1]){  
8.                 break;  
9.             }  
10.         }else{  
11.             change=arr[top*2+1]>arr[top*2+2]?top*2+1:top*2+2;  
12.             if(arr[top]>=arr[change]){  
13.                 break;  
14.             }  
15.         }  
16.         int t=arr[top];arr[top]=arr[change];arr[change]=t;  
17.         top=change;  
18.     }  
19. }  
20. //建堆  
21. public static void buildHeap(int[] arr){  
22.     for(int top=(arr.length)/2;top>=0;top--){  
23.         adjustHeap(arr,arr.length,top);  
24.     }  
25. }  
26. //堆排序  
27. public static void heapSort(int[] arr){  
28.     buildHeap(arr);  
29.     for(int i:arr){  
30.         System.out.print(i+" ");  
31.     }  
32.     System.out.println();  
33.     for(int size=arr.length;size>=2;size--){  
34.         int t=arr[0];arr[0]=arr[size-1];arr[size-1]=t;  
35.         adjustHeap(arr,size-1,0);  
36.     }  
37. }  

特征分析：

1、空间复杂度O(1)，平均时间复杂度O（n log n）,依次堆调整O(log n)——即堆的高度。由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数量较少的情况。

2、堆排序时不稳定的。

交换排序

冒泡排序

基本思想：
比较相邻的元素，如果前者比后者大，就交换他们两个，对从前往后对每一对相邻元素作同样的工作，这样一趟冒泡后，最后的元素就是最大的数。这样每一趟冒泡确定一个元素的位置，n趟后数组即有序。同样也可以从后往前冒泡，依次确定最小值。

[java]  view plain  copy

1. public static void bubbleSort(int[] arr){  
2.     for(int end=arr.length-1;end>0;end--){  
3.         boolean changed=false;  
4.         for(int index=0;index<end;index++){  
5.             if(arr[index]>arr[index+1]){  
6.                 int t=arr[index+1];  
7.                 arr[index+1]=arr[index];  
8.                 arr[index]=t;  
9.                 changed=true;  
10.             }  
11.         }  
12.         if(changed==false) return;  
13.     }  
14. }  

特征分析：

1、空间复杂度O(1)，最好时间复杂度O(n)，最坏时间复杂度O(n^2)，平均时间复杂度O(n^2)。
2、冒泡排序时稳定的。

快速排序

基本思想：

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

递归版

[java]  view plain  copy

1. public static int partition(int[] arr,int start,int end){  
2.     int part=arr[start];  
3.     int locate=start;  
4.     while(start<end){  
5.         while(end>start&&arr[end]>part)end--;  
6.         if(end<=start){  
7.             break;  
8.         }  
9.         arr[locate]=arr[end];  
10.         locate=end;  
11.         while(start<end&&arr[start]<=part) start++;  
12.         if(start>=end){  
13.             break;  
14.         }  
15.         arr[locate]=arr[start];  
16.         locate=start;  
17.     }  
18.     arr[locate]=part;  
19.     return locate;  
20. }  
21. public static void quickSort(int[] arr,int start,int end){  
22.     if(start>=end) return;  
23.     int mid=partition(arr,start,end);  
24.     quickSort(arr,start,mid-1);  
25.     quickSort(arr,mid+1,end);  
26. }  

跌代版

[java]  view plain  copy

1. public static void quickSort(int[] arr){   
2.  Stack<Integer> stack=new Stack<Integer>();  
3.  stack.push(0);stack.push(arr.length-1);  
4.  while(stack.empty()==false){  
5.      int end=stack.pop(),start=stack.pop();  
6.      if(start>=end) continue;  
7.      int part=arr[start];  
8.      int locate =start;  
9.      int pre=start,post=end;  
10.      while(pre<post){  
11.          while(pre<post&&arr[post]>part)post--;  
12.          if(pre>post) break;  
13.          arr[locate]=arr[post];  
14.          locate=post;  
15.          while(pre<post&&arr[pre]<=part)pre++;  
16.          if(pre>post) break;  
17.          arr[locate]=arr[pre];  
18.          locate=pre;   
19.      }  
20.      arr[locate]=part;  
21.      stack.push(start);stack.push(locate-1);  
22.      stack.push(locate+1);stack.push(end);  
23.  }  

特征分析：

1、最好空间复杂度O(log(n))，最坏空间复杂度O（n），平均空间复杂度O(log n)；最好时间复杂度O(n log n)，最坏时间复杂度O(n^2)，平均时间复杂度O(n log n)。

2、快速排序时不稳定的。

改进

在最坏的情况下，每次划分都将n个元素划分为n-1个元素和1个元素，我们可以通过采取措施尽量较少这种不对称划分来优化算法。例如，我们在选取划分元素时，不是选取特定位置的元素，而是采取随机选取的方式或者随机取三个元素并选定其中值进行划分。

归并排序

基本思想：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

递归版

[java]  view plain  copy

1. public static void merge(int[] arr,int start1,int start2,int end2,int[] temp){  
2.     int end1=start2-1,index=0;  
3.     int p=start1,q=start2;  
4.     while(p<=end1||q<=end2){  
5.         if(q>end2||(p<=end1&&arr[p]<arr[q])){  
6.             temp[index++]=arr[p++];  
7.         }else{  
8.             temp[index++]=arr[q++];  
9.         }    
10.     }  
11.     for(int i=0;i<index;i++){  
12.         arr[start1+i]=temp[i];  
13.     }  
14. }  
15.    public static void mergeSort(int[] arr,int start,int end,int[] temp){  
16.        if(start>=end) return;  
17.        int mid=start+(end-start)/2;  
18.        mergeSort(arr,start,mid,temp);  
19.        mergeSort(arr,mid+1,end,temp);  
20.        merge(arr,start,mid+1,end,temp);  
21.    }   

迭代版

[java]  view plain  copy

1. public static void mergeSort(int[] arr,int[] temp){  
2.         int size=1,low,mid,high,n=arr.length;    
3.         while(size<=n-1)    
4.         {    
5.             low=0;    
6.             while(low+size<=n-1)    
7.             {    
8.                 mid=low+size-1;    
9.                 high=mid+size;    
10.                 if(high>n-1)//第二个序列个数不足size     
11.                     high=n-1;           
12.                 merge(arr,low,mid+1,high,temp);//调用归并子函数   
13.                 System.out.println("low:"+low+" mid:"+mid+" high:"+high);   
14.                 low=high+1;//下一次归并时第一关序列的下界     
15.             }    
16.             size*=2;//范围扩大一倍     
17.         }    
18.     }   

特征分析：

1、空间复杂度O(n)，时间复杂度O(1)。

2、归并排序时稳定的排序。

线性时间排序

计数排序

基本思想：

是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。例如，如果输入序列中只有17个元素的值小于x的值，则x可以直接存放在输出序列的第18个位置上。当然，如果有多个元素具有相同的值时，我们不能将这些元素放在输出序列的同一个位置上，因此，上述方案还要作适当的修改。

[java]  view plain  copy

1. public static int[] countSort(int[] a){  
2.     int b[] = new int[a.length];  
3.         int max = a[0],min = a[0];  
4.         for(int i:a){  
5.             if(i>max) max=i;  
6.             if(i<min) min=i;  
7.         }//这里k的大小是要排序的数组中，元素大小的极值差+1  
8.         int k=max-min+1;  
9.         int c[]=new int[k];  
10.         for(int i=0;i<a.length;++i){  
11.             c[a[i]-min]+=1;//优化过的地方，减小了数组c的大小  
12.         }  
13.         for(int i=1;i<c.length;++i){  
14.             c[i]=c[i]+c[i-1];  
15.         }  
16.         for(int i=a.length-1;i>=0;--i){  
17.             b[--c[a[i]-min]]=a[i];//按存取的方式取出c的元素  
18.         }  
19.         return b;  
20. }  

特征分析：

1、空间复杂度O(k+n)（k为数据范围），时间复杂度O(n+k)。

2、计数排序时稳定的。

变形：

出来了通过统计出现次数之外，我们还可以用链表记录数值相同的元素。

适用场景：

1、当k=O(n)时。

基数排序

基本思想：
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用。

[java]  view plain  copy

1.    // d为数据长度  
2.    private static void radixSorting(int[] arr, int d) {    
3.        for (int i = 1; i <=d; i++) {  
4.            int[] res = countingSort(arr, i); // 依次对各位数字排序（直接用计数排序的变体）  
5.            for(int j=0;j<arr.length;j++){  
6.                arr[j]=res[j];  
7.            }   
8.        }   
9.    }   
10.    // 利用计数排序对元素的每一位进行排序  
11.    private static int[] countingSort(int[] arr, int expIndex) {  
12.        int k = 9;  
13.        int[] b = new int[arr.length];  
14.        int[] c = new int[k + 1]; // 这里比较特殊：数的每一位最大数为9  
15.        for (int i = 0; i < k; i++) {  
16.            c[i] = 0;  
17.        }  
18.        for (int i = 0; i < arr.length; i++) {  
19.            int d = getBitData(arr[i], expIndex);  
20.            c[d]++;  
21.        }  
22.        for (int i = 1; i <= k; i++) {  
23.            c[i] += c[i - 1];  
24.        }  
25.        for (int i = arr.length - 1; i >= 0; i--) {  
26.            int d = getBitData(arr[i], expIndex);  
27.            b[c[d] - 1] = arr[i];// C[d]-1 就代表小于等于元素d的元素个数，就是d在B的位置  
28.            c[d]--;  
29.        }  
30.        return b;  
31.    }  
32.    // 获取data指定位的数  
33.    private static int getBitData(int data, int expIndex) {  
34.        while (data != 0 && expIndex > 0) {  
35.            data /= 10;  
36.            expIndex--;  
37.        }  
38.        return data % 10;  
39.    }  
40.   
41. public static int[] countSort(int[] a){  
42.     int b[] = new int[a.length];  
43.        int max = a[0],min = a[0];  
44.        for(int i:a){  
45.            if(i>max) max=i;  
46.            if(i<min) min=i;  
47.        }//这里k的大小是要排序的数组中，元素大小的极值差+1  
48.        int k=max-min+1;  
49.        int c[]=new int[k];  
50.        for(int i=0;i<a.length;++i){  
51.            c[a[i]-min]+=1;//优化过的地方，减小了数组c的大小  
52.        }  
53.        for(int i=1;i<c.length;++i){  
54.            c[i]=c[i]+c[i-1];  
55.        }  
56.        for(int i=a.length-1;i>=0;--i){  
57.            b[--c[a[i]-min]]=a[i];//按存取的方式取出c的元素  
58.        }  
59.        return b;  
60. }  

特征分析：
1、基数排序法是属于稳定性的排序。
2、时间复杂度为O (nlog(k)d)，其中d为所采取的基数，而k为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

桶排序

基本思想：
将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序利用函数的映射关系，减少了几乎所有的比较工作。实际上，桶排序的f(k)值的计算，其作用就相当于快排中划分，已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。

简单桶排序实现

[java]  view plain  copy

1. //假如排序的数据范围为（0-100），学生成绩  
2.    public static void bucketSort(int[] arr){  
3.        List<List<Integer>> buckets=new ArrayList<List<Integer>>();  
4.        buckets.add(new ArrayList<Integer>());//成绩0-59的桶  
5.        buckets.add(new ArrayList<Integer>());//成绩60-69  
6.        buckets.add(new ArrayList<Integer>());//成绩70-79  
7.        buckets.add(new ArrayList<Integer>());//成绩80-100   
8.        for(int i:arr){  
9.            if(i>=0&&i<=59)    buckets.get(0).add(i);  
10.            if(i>=60&&i<=69)   buckets.get(1).add(i);  
11.            if(i>=70&&i<=79)   buckets.get(2).add(i);  
12.            if(i>=80&&i<=100)  buckets.get(3).add(i);   
13.        }  
14.        for(List<Integer> bucket:buckets){  
15.            Collections.sort(bucket);  
16.        }  
17.        int index=0;  
18.        for(List<Integer> bucket:buckets){  
19.            for(int i:bucket){  
20.                arr[index++]=i;  
21.            }  
22.        }  
23.    }  

特征分析：
1、对于N个待排数据，M个桶，如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。当然桶排序的空间复杂度为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。
2、桶排序是稳定的（如果桶内数据的排序算法选择的不是稳定的，桶排序就变成不稳定的）。

适用场景：

1、输入数据符合均匀分布。

2、在面试的海量数据处理题目中，如对每天数以亿计的数据进行排序，直接排序即使采用nlgn的算法，依然是一件很恐怖的事情，内存也无法容纳如此多的数据，这时桶排序就可以有效地降低数据的数量级，再对降低了数量级的数据进行排序，可以得到比较良好的效果。

面试题

[java]  view plain  copy

1. public class Solution {  
2.     public boolean isAnagram(String s, String t) {  
3.         if(s.length()!=t.length()) return false;  
4.         char[] a=s.toCharArray();  
5.         char[] b=t.toCharArray();  
6.         Arrays.sort(a);  
7.         Arrays.sort(b);  
8.         boolean res;  
9.         for(int i=0;i<a.length;i++){  
10.             if(a[i]!=b[i]){  
11.                 return false;  
12.             }  
13.         }  
14.         return true;  
15.     }  
16. }  

分析

题目中指明不能利用类库中的排序函数，即使允许效率也是低下的。

由于元素的值是确切的三种类型，0、1、2。我们可以利用快速排序的划分算法，每次划分就可以解决一个数值的元素的排序。

[java]  view plain  copy

1. public class Solution {  
2.     public int partition(int[] nums,int value,int begin,int end){  
3.         int p=begin,q=end;  
4.         while(p<q){  
5.             while(p<=end&&nums[p]==value)p++;  
6.             while(q>=begin&&nums[q]>value)q--;  
7.             if(p<q){  
8.                 int t=nums[p];nums[p]=nums[q];nums[q]=t;  
9.             }  
10.         }  
11.         return p;  
12.     }  
13.     public void sortColors(int[] nums) {  
14.         if(nums.length<=1) return;  
15.         int nextBegin=partition(nums,0,0,nums.length-1);  
16.         if(nextBegin<nums.length){  
17.             partition(nums,1,nextBegin,nums.length-1);  
18.         }  
19.     }  
20. }  

分析

链表只具有顺序存取特性，只能使用简单插入排序。

[java]  view plain  copy

1. public class Solution {  
2.     public ListNode insertionSortList(ListNode head) {  
3.         ListNode myHead=new ListNode(-1),p;  
4.         while(head!=null){  
5.             p=head;  
6.             head=head.next;  
7.             insertElement(myHead,p);  
8.         }  
9.         return myHead.next;  
10.     }  
11.     private void insertElement(ListNode myHead,ListNode p){  
12.         ListNode pre=myHead,post=myHead.next;  
13.         while(post!=null&&post.val<=p.val){  
14.             pre=post;  
15.             post=post.next;  
16.         }  
17.         p.next=post;  
18.         pre.next=p;  
19.     }  
20. }  

分析

由于要求时间复杂度为O(n log n),空间复杂度O(1)。那么我们想到符合这样的复杂度的排序算法只可能为堆排序、归并排序。

由于空间复杂度为O(1)的堆排序，要求随机存取特性，而链表显然不具有这样的特性，因此只能使用归并排序。

[java]  view plain  copy

1.   public static ListNode sortList(ListNode head) {  
2.     int length=0;  
3.     ListNode p=head;  
4.     while(p!=null){  
5.         length++;  
6.         p=p.next;  
7.     }  
8.     if(length<=1) return head;   
9.     ListNode myHead=new ListNode(-1);  
10.     myHead.next=head;  
11. mergerSort(myHead,length);  
12.       return myHead.next;  
13.   }  
14.   private static void mergerSort(ListNode myHead,int length){  
15.     ListNode pre,start,end;  
16.     int size=1;  
17.     while(size<length){   
18.         pre=myHead;  
19.         while(pre.next!=null){  
20.             start=pre.next;  
21.             pre.next=merge(start,size);  
22.             int count=size*2;  
23.             while(count>0&&pre!=null){  
24.                 pre=pre.next;  
25.                 count--;  
26.             }  
27.             if(count>0||pre==null||pre.next==null) break;  
28.         }  
29.         size*=2;  
30.     }  
31.   }  
32.   private static ListNode merge(ListNode start,int size){  
33.     ListNode myHead=new ListNode(-1),end=myHead,second,last;  
34.     int count=size;  
35.     second=start;  
36.     while(count>0&&second!=null){  
37.         second=second.next;  
38.         count--;  
39.     }   
40.     if(count>0) return start;//长度不够一个size  
41.     count=size;  
42.     last=second;  
43.     while(count>0&&last!=null){  
44.         last=last.next;  
45.         count--;  
46.     }   
47.     ListNode p=start,q=second,t;  
48.     while(p!=second||q!=last){  
49.         if(q==last||(p!=second&&p.val<=q.val)){  
50.               
51.             t=p;   
52.             p=p.next;  
53.             t.next=null;  
54.             end.next=t;  
55.             end=end.next;   
56.         }else{  
57.             t=q;   
58.             q=q.next;  
59.             t.next=null;  
60.             end.next=t;  
61.             end=end.next;  
62.         }  
63.     }  
64.     end.next=last;  
65. return myHead.next;   
66.   }  

[java]  view plain  copy

1. public class Solution {  
2.     public String largestNumber(int[] nums) {  
3.         if (nums == null || nums.length == 0) return "";  
4.         String[] strs = new String[nums.length];  
5.         for (int i = 0; i < nums.length; i++) {  
6.             strs[i] = nums[i]+"";  
7.         }  
8.         Arrays.sort(strs, new Comparator<String>() {  
9.             @Override  
10.             public int compare(String i, String j) {  
11.                 String s1 = i+j;  
12.                 String s2 = j+i;  
13.                 return s2.compareTo(s1);  
14.             }  
15.         });  
16.         //降序,直接比较i+j和j+i，就可以判断哪个应该放在前面  
17.         if (strs[0].charAt(0) == '0') return "0";//最大为0,结果必为0  
18.         StringBuilder res = new StringBuilder();  
19.         for (String s:strs) {  
20.             res.append(s);  
21.         }  
22.         return res.toString();  
23.     }  
24. }