排序總結-常用排序算法Java實現

排序總結

穩定

sort	最差時間	最好時間	平均時間	穩定	空間複雜度
冒泡排序	O(n^2)	O(n)	O(n^2)	穩定	O(1)
插入排序	O(n^2)	O(n)	O(n^2)	穩定	O(1)
二叉樹排序	O(n^2)	O(nlogn)	O(nlogn)	穩定	O(n)
歸併排序l	O(nlogn)	O(nlogn)	O(nlogn)	穩定	O(n)

不穩定

sort	最差時間	最好時間	平均時間	穩定	空間複雜度
選擇排序	O(n^2)	O(n^2)	O(n^2)	不穩定	O(1)
快排	O(n^2)	O(nlogn)	O(nlogn)	不穩定	O(logn~ O(n))
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	不穩定	O(1)
希爾排序	O(n^2)			不穩定	O(1)

冒泡排序(Bubble Sort)

它是一種較簡單的排序算法。它會遍歷若干次要排序的數列，每次遍歷時，它都會從前往後依次的比較相鄰兩個數的大小；如果前者比後者大，則交換它們的位置。這樣，一次遍歷之後，最大的元素就在數列的末尾！採用相同的方法再次遍歷時，第二大的元素就被排列在最大元素之前。重複此操作，直到整個數列都有序爲止！

/*
 * a -- 待排序的數組
 * n -- 數組的長度
 */
public static void bubbleSort(int[] a, int n) {
    int i,
    j;
    for (i = n - 1; i > 0; i--) {
        // 將a[0...i]中最大的數據放在末尾
        for (j = 0; j < i; j++) {
            if (a[j] > a[j + 1]) {
                // 交換a[j]和a[j+1]
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
            }
        }
    }
}


運行：
int[] a = {20,40,30,10,60,50,70};
String aa = "冒泡排序";
bubbleSort(a, a.length);
System.out.print(aa);
for (int d: a) {
    System.out.print(d + ",");
}

選擇排序和插入排序都是在冒泡基礎上的演進：
選擇排序：選出最小的值放入列表，選完即可
直接插入排序：左側爲有序隊列，從右側遍歷的數字在放入左側有序隊列時排序插入。

直接插入排序(Straight Insertion Sort)

/**
 * @param 
 * a -- 待排序的數組
 * n -- 數組的長度
 */
public static void insertSort(int[] a, int n) {
    int i,j,k;
    for (i = 1; i < n; i++) {
    	//a[i]爲右側遍歷出的待插數據
        //在有序隊列a[0,i]中爲a[i]在前面的a[0...i-1]有序區間中找一個合適的位置
        for (j = i - 1; j >= 0; j--) if (a[j] < a[i]) break;//從大到小找到比i小的值j即可終止
        //如找到了一個合適的位置, 把整個數組下標大於j的值都往後移動一個空位給i使用
        if (j != i - 1) {
            //將比a[i]大的數據向後移
            int temp = a[i];
            for (k = i - 1; k > j; k--) a[k + 1] = a[k];
            //將a[i]放到正確位置上
            a[k + 1] = temp;
        }
    }
}

和冒泡的規則相同，雙重for循環找到最最小值

快速排序(Quick Sort)

使用分治法策略
它的基本思想是：選擇一個基準數，通過一趟排序將要排序的數據分割成獨立的兩部分；其中一部分的所有數據都比另外一部分的所有數據都要小。然後，再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

快速排序流程：
1.從數列中挑出一個基準值放入x。
2.將所有比基準值小的擺放在基準前面，所有比基準值大的擺在基準的後面(相同的數可以到任一邊)；在這個分區退出之後，該基準就處於數列的中間位置（把x賦值給中間值，完成一輪互換）。
3.遞歸地把"基準值前面的子數列"和"基準值後面的子數列"進行排序。

圖文介紹

/**
 *
 * 參數說明：
 * a -- 待排序的數組
 * l -- 數組的左邊界(例如，從起始位置開始排序，則l=0)
 * r -- 數組的右邊界(例如，排序截至到數組末尾，則r=a.length-1)
 */
public static void quickSort(int[] a, int l, int r) {
    if (l < r) {
        int i,j, x;
        i = l;
        j = r;
        x = a[i];
        while (i < j) {
            while (i < j && a[j] > x) j--; // 從右向左找第一個小於x的數
            if (i < j) a[i++] = a[j];
            while (i < j && a[i] < x) i++; // 從左向右找第一個大於x的數
            if (i < j) a[j--] = a[i];
        }
        a[i] = x;//最後把基準值賦值給中間值，完成一輪替換
         /* 遞歸調用 */
        quickSort(a, l, i - 1);//把中間值左側數據排序
        quickSort(a, i + 1, r);//右側數據排序
        /* 遞歸調用 */
    }
}


//運行
 String aa = "快速排序";
 quickSort(a,0,a.length-1);
 System.out.print(aa);
 for (int d : a) {
 System.out.print(d+",");
 }

希爾排序shell sort

希爾(Shell)排序又稱爲縮小增量排序，它是一種插入排序。它是直接插入排序算法的一種威力加強版。該方法因DL．Shell於1959年提出而得名。

希爾排序的基本思想是：
1.把記錄按步長 gap 分組，對每組記錄採用直接插入排序方法進行排序。
2.隨着步長逐漸減小，所分成的組包含的記錄越來越多，當步長的值減小到 1 時，整個數據合成爲一組，構成一組有序記錄，則完成排序。

看圖配合步驟講解，第一次gap=5,每隔gap個元素爲一組比大小；gap不斷對摺，直到gap=1完成排序。

初始時，有一個大小爲 10 的無序序列。

在第一趟排序中，我們不妨設 gap1 = N / 2 = 5，即相隔距離爲 5 的元素組成一組，可以分爲 5 組。接下來，按照直接插入排序的方法對每個組進行排序。

在第二趟排序中，我們把上次的 gap 縮小一半，即 gap2 = gap1 / 2 = 2 (取整數)。這樣每相隔距離爲 2 的元素組成一組，可以分爲 2 組。按照直接插入排序的方法對每個組進行排序。

在第三趟排序中，再次把 gap 縮小一半，即gap3 = gap2 / 2 = 1。這樣相隔距離爲 1 的元素組成一組，即只有一組。按照直接插入排序的方法對每個組進行排序。此時，排序已經結束。

需要注意一下的是，圖中有兩個相等數值的元素 5 和 5 。我們可以清楚的看到，在排序過程中，兩個元素位置交換了。

所以，希爾排序是不穩定的算法。

/**
 * 希爾排序
 * @param list
 */
 public static void shellSort(int[] a) {
	 int gap = a.length / 2; //初始對摺=步長
	 while (1 <= gap) {
		 // 把距離爲 gap 的元素編爲一個組，掃描所有組
		 for (int i = gap; i < a.length; i++) {
			 int j = 0;
			 int temp = a[i];
			 // 對距離爲 gap 的元素組進行排序,每隔gap個爲一組對比大小
			 for (j = i - gap; j >= 0 && temp < a[j]; j = j - gap) {
			 	a[j + gap] = a[j];
			 }
			 a[j + gap] = temp;
		 }
		 System.out.format("gap = %d:\t", gap);
		 printAll(a);
		 gap = gap / 2; // 減小增量
	 }
}
	 // 打印完整序列
 public static void printAll(int[] a) {
	 for (int value : a) {
	 System.out.print(value + "\t");
	 }
	 System.out.println();
 }

歸併排序

基本思想
歸併排序（MERGE-SORT）是利用歸併的思想實現的排序方法，該算法採用經典的分治（divide-and-conquer）策略（分治法將問題分(divide)成一些小的問題然後遞歸求解，而治(conquer)的階段則將分的階段得到的各答案"修補"在一起，即分而治之)。

分而治之

和希爾排序的思想視乎有些相似，都是對摺分組
可以看到這種結構很像一棵完全二叉樹，本文的歸併排序我們採用遞歸去實現（也可採用迭代的方式去實現）。分階段可以理解爲就是遞歸拆分子序列的過程，遞歸深度爲log2n。

每個小組最後都要面對的一步：合併相鄰有序子序列
再來看看治階段，我們需要將兩個已經有序的子序列合併成一個有序序列，比如上圖中的最後一次合併，要將[4,5,7,8]和[1,2,3,6]兩個已經有序的子序列，合併爲最終序列[1,2,3,4,5,6,7,8]，來看下實現步驟。

思路：創建一個兩個數組長度之和的臨時數組temp，兩個數組對比，誰小就放入temp中。對比完成

public class MergeSort {
 public static void main(String []args){
	 int []arr = {9,8,7,6,5,4,3,2,1};
	 sort(arr);
	 System.out.println(Arrays.toString(arr));
 }

 public static void sort(int []arr){
	 int []temp = new int[arr.length];
	 //在排序前，先建好一個長度等於原數組長度的臨時數組，
	 //避免遞歸中頻繁開闢空間
	 sort(arr,0,arr.length-1,temp);
 }
 
 private static void sort(int[] arr,int left,int right,int []temp){
	 if(left<right){
		 int mid = (left+right)/2;
		 sort(arr,left,mid,temp);//遞歸調用：左邊歸併排序，使得左子序列有序
		 sort(arr,mid+1,right,temp);//遞歸調用：右邊歸併排序，使得右子序列有序
		 merge(arr,left,mid,right,temp);//將兩個有序子數組合並操作
	 }
 }
 private static void merge(int[] arr,int left,int mid,int right,int[] temp){
	 int i = left;//左序列指針
	 int j = mid+1;//右序列指針
	 int t = 0;//臨時數組指針
	 while (i<=mid && j<=right){
		 if(arr[i]<=arr[j]){
		 	temp[t++] = arr[i++];
		 }else {
			 temp[t++] = arr[j++];
		 }
	 }
	 while(i<=mid){//將左邊剩餘元素填充進temp中
	 temp[t++] = arr[i++];
	 }
	 while(j<=right){//將右序列剩餘元素填充進temp中
	 temp[t++] = arr[j++];
	 }
	 t = 0;
	 //將temp中的元素全部拷貝到原數組中
	 while(left <= right){
	 arr[left++] = temp[t++];
	 }
 }
}

堆排序

堆排序(Heapsort)是指利用堆積樹（堆）這種數據結構所設計的一種排序算法，它是選擇排序的一種。可以利用數組的特點快速定位指定索引的元素。堆分爲大根堆和小根堆，是完全二叉樹。

• 完全二叉樹： 除了最後一層之外的其他每一層都被完全填充，並且所有結點都保持向左對齊。
• 滿二叉樹：除了葉子結點之外的每一個結點都有兩個孩子，每一層(當然包含最後一層)都被完全填充。
• 完滿二叉樹：除了葉子結點之外的每一個結點都有兩個孩子結點。

完全二叉樹(Complete Binary Tree)：

滿二叉樹(Perfect Binary Tree)：

完滿二叉樹(Full Binary Tree)：

參考資料：
http://www.cnblogs.com/idorax/p/6441043.html

堆排序是將數據看成是完全二叉樹、根據完全二叉樹的特性來進行排序的一種算法
最大堆要求節點的元素都要不小於其孩子，
最小堆要求節點元素都不大於其左右孩子
處於最大堆的根節點的元素一定是這個堆中的最大值

完全二叉樹有個特性：
左邊子節點位置 = 當前父節點的兩倍 + 1
右邊子節點位置 = 當前父節點的兩倍 + 2

節點的關係和節點編號和數組下標對象的下標關係：

排序過程
第一步：先n個元素的無序序列，構建成大頂堆
第二步：將根節點與最後一個元素交換位置，（將最大元素"沉"到數組末端）
第三步：交換過後可能不再滿足大頂堆的條件，所以需要將剩下的n-1個元素重新構建成大頂堆
第四步：重複第二步、第三步直到整個數組排序完成

/**
     * 建堆
     *
     * @param arrays          看作是完全二叉樹
     * @param currentRootNode 當前父節點位置
     * @param size            節點總數
     */
    public static void heapify(int[] arrays, int currentRootNode, int size) {

       if (currentRootNode < size) {
           //左子樹和右字數的位置
           int left = 2 * currentRootNode + 1;
           int right = 2 * currentRootNode + 2;

           //把當前父節點位置看成是最大的
           int max = currentRootNode;

           if (left < size) {
               //如果比當前根元素要大，記錄它的位置
               if (arrays[max] < arrays[left]) {
                   max = left;
               }
           }
           if (right < size) {
               //如果比當前根元素要大，記錄它的位置
               if (arrays[max] < arrays[right]) {
                   max = right;
               }
           }
           //如果最大的不是根元素位置，那麼就交換
           if (max != currentRootNode) {
               int temp = arrays[max];
               arrays[max] = arrays[currentRootNode];
               arrays[currentRootNode] = temp;

               //繼續比較，直到完成一次建堆
               heapify(arrays, max, size);
           }
       }
   }



  /**
    * 完成一次建堆，最大值在堆的頂部(根節點)
    */
   public static void maxHeapify(int[] arrays, int size) {

       // 從數組的尾部開始，直到第一個元素(角標爲0)
       for (int i = size - 1; i >= 0; i--) {
           heapify(arrays, i, size);
       }

   }

	//堆排序入口
public static void heapSort(int[] arrays) {
	for (int i = 0; i < arrays.length; i++) {
        //每次建堆就可以排除一個元素了
        maxHeapify(arrays, arrays.length - i);
        //把頂部最大值放到數組最後面
        int temp = arrays[0];
        arrays[0] = arrays[(arrays.length - 1) - i];
        arrays[(arrays.length - 1) - i] = temp;
    }
}