Java自帶的排序

1. Java中自帶了兩種排序方法， 一種是 Collections.sort()， 另一種是 Arrays.sort()
   原理轉載自： https://blog.csdn.net/u011410529/article/details/56668545， 內容如下：

   ---

   Arrays.sort和Collections.sort實現原理解析

1、使用

• 排序

2、原理

1. 事實上Collections.sort方法底層就是調用的array.sort方法，而且不論是Collections.sort或者是Arrays.sort方法，

2. 跟蹤下源代碼吧，首先我們寫個demo

public static void main(String[] args) {
                 List<String> strings = Arrays.asList("6", "1", "3", "1","2");

                 Collections.sort(strings);//sort方法在這裏

                 for (String string : strings) {

                     System.out.println(string);
                 }
             }

簡單得不能再簡單的方法了，讓我們一步步跟蹤

1. OK，往下面看，發現collections.sort方法調用的list.sort

1. 然後跟蹤一下，list裏面有個sort方法，但是list是一個接口，肯定是調用子類裏面的實現，這裏我們demo使用的是一個Arrays.asList方法，所以事實上我們的子類就是arraylist了。OK，看arraylist裏面sort實現，選擇第一個，爲什麼不選擇第二個呢？（因爲在創建List對象的時候，使用了`Arrays.asList()`方法，從其實現源碼可以看出，該方法創建的ArrayList對象其實是Arrays類內部自帶的，所以在debug跟蹤源代碼的時候，進入的是Arrays內部的ArrayList對象。）

​

1. OK，發現裏面調用的Arrays.sort(a, c); a是list,c是一個比較器，我們來看一下這個方法
   

我們沒有寫比較器，所以用的第二項，LegacyMergeSort.userRequested這個bool值是什麼呢？
跟蹤這個值，我們發現有這樣的一段定義：

  > Old merge sort implementation can be selected (for
  >  compatibility with broken comparators) using a system property.
  >  Cannot be a static boolean in the enclosing class due to
  >  circular dependencies. To be removed in a future release.

  反正是一種老的歸併排序，不用管了現在默認是關的

1. OK，我們走的是sort(a)這個方法，接着進入這個
   
2. 接着看我們重要的sort方法

static void sort(Object[] a, int lo, int hi, Object[] work, int workBase, int workLen) {
                 assert a != null && lo >= 0 && lo <= hi && hi <= a.length;

                 int nRemaining  = hi - lo;
                 if (nRemaining < 2)
                     return;  // array的大小爲0或者1就不用排了

                 // 當數組大小小於MIN_MERGE(32)的時候，就用一個"mini-TimSort"的方法排序，jdk1.7新加
                 if (nRemaining < MIN_MERGE) {
                    //這個方法比較有意思，其實就是將我們最長的遞減序列，找出來，然後倒過來
                     int initRunLen = countRunAndMakeAscending(a, lo, hi);
                     //長度小於32的時候，是使用binarySort的
                     binarySort(a, lo, hi, lo + initRunLen);
                     return;
                 }
                //先掃描一次array，找到已經排好的序列，然後再用剛纔的mini-TimSort，然後合併，這就是TimSort的核心思想
                 ComparableTimSort ts = new ComparableTimSort(a, work, workBase, workLen);
                 int minRun = minRunLength(nRemaining);
                 do {
                     // Identify next run
                     int runLen = countRunAndMakeAscending(a, lo, hi);

                     // If run is short, extend to min(minRun, nRemaining)
                     if (runLen < minRun) {
                         int force = nRemaining <= minRun ? nRemaining : minRun;
                         binarySort(a, lo, lo + force, lo + runLen);
                         runLen = force;
                     }

                     // Push run onto pending-run stack, and maybe merge
                     ts.pushRun(lo, runLen);
                     ts.mergeCollapse();

                     // Advance to find next run
                     lo += runLen;
                     nRemaining -= runLen;
                 } while (nRemaining != 0);

                 // Merge all remaining runs to complete sort
                 assert lo == hi;
                 ts.mergeForceCollapse();
                 assert ts.stackSize == 1;
         }

1. 回到5，我們可以看到當我們寫了比較器的時候就調用了TimSort.sort方法，源碼如下

static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                                  T[] work, int workBase, int workLen) {
                 assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

                 int nRemaining  = hi - lo;
                 if (nRemaining < 2)
                     return;  // Arrays of size 0 and 1 are always sorted

                 // If array is small, do a "mini-TimSort" with no merges
                 if (nRemaining < MIN_MERGE) {
                     int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
                     binarySort(a, lo, hi, lo + initRunLen, c);
                     return;
                 }

                 /**
                  * March over the array once, left to right, finding natural runs,
                  * extending short natural runs to minRun elements, and merging runs
                  * to maintain stack invariant.
                  */
           TimSort<T> ts = new TimSort<>(a, c, work, workBase, workLen);
                int minRun = minRunLength(nRemaining);
                do {
                    // Identify next run
                    int runLen = countRunAndMakeAscending(a, lo, hi, c);

                    // If run is short, extend to min(minRun, nRemaining)
                    if (runLen < minRun) {
                        int force = nRemaining <= minRun ? nRemaining : minRun;
                        binarySort(a, lo, lo + force, lo + runLen, c);
                        runLen = force;
                    }

                    // Push run onto pending-run stack, and maybe merge
                    ts.pushRun(lo, runLen);
                    ts.mergeCollapse();

                    // Advance to find next run
                    lo += runLen;
                    nRemaining -= runLen;
                } while (nRemaining != 0);

                // Merge all remaining runs to complete sort
                assert lo == hi;
                ts.mergeForceCollapse();
                assert ts.stackSize == 1;
      }

和上面的sort方法是一樣的，其實也就是TimSort的源代碼

3、總結

不論是Collections.sort方法或者是Arrays.sort方法，底層實現都是TimSort實現的，這是jdk1.7新增的，以前是歸併排序。TimSort算法就是找到已經排好序數據的子序列，然後對剩餘部分排序，然後合併起來

---

由上面的文章我們可以看出 自帶的兩種排序方法在 jdk1.7之前都用的是歸併排序， 現在都用的是 TimSort, TimSort 算法的實現原理是：找到已經排好序的子序列，然後再將剩下的數據排序，然後再合併。
TimSort算法實現原理見文章： TimSort實現原理
Timsort是穩定的算法，當待排序的數組中已經有排序好的數，它的時間複雜度會小於n logn。與其他合併排序一樣，Timesort是穩定的排序算法，最壞時間複雜度是O（n log n）。在最壞情況下，Timsort算法需要的臨時空間是n/2，在最好情況下，它只需要一個很小的臨時存儲空間