Java快速排序和歸併排序詳解

快速排序

概述

快速排序算法借鑑的是二叉樹前序遍歷的思想，最終對數組進行排序。算法

優勢：

對於數據量比較大的數組排序，因爲採用的具備二叉樹二分的思想，故排序速度比較快數組

侷限

只適用於順序存儲結構的數據排序（數組，ArrayList等），不適用於鏈式的數據結構數據結構

算法實現思路

一.將目標數組轉化爲這樣一個數組。數組中的某個位置左邊的全部數據都比該位置的數據小，該位置右邊的數據都比該位置數據大。

實現思路：

1.取出數組第0個數據

2.從數組最右邊開始遍歷，若是遍歷位置的數據比第0個位置的數據小，將該位置的數據賦值給左邊指針停留下的位置。

3.改變遍歷方向，從左邊開始開始遍歷，若是發現左邊的數據比第0個位置的數據大，將該位置的數據賦值給2步驟停留下來的位置，並變換方向。測試

4.循環二、3步驟直到左右遍歷到的下標重合
5.將取出的第0個位置的值賦值給循環結束後左右指針停留下的位置ui

二. 借鑑前序遍歷的思路，遞歸，最終完成排序。

代碼實現

 1 private void quickSort(int[] array, int start, int end) {
 2         if (start >= end) {
 3             return;
 4         }
 5         int key = array[start];
 6         int left = start;
 7         int right = end;
 8         boolean direction = true;
 9         L1:
10         while (left < right) {
11             if (direction) {
12                 for (int i = right; i > left; i--) {
13                     if (array[i] < key) {
14                         array[left++] = array[i];
15                         right = i;
16                         direction = !direction;
17                         continue L1;
18                     }
19                 }
20                 right = left;
21             } else {
22                 for (int i = left; i < right; i++) {
23                     if (array[i] > key) {
24                         array[right--] = array[i];
25                         left = i;
26                         direction = !direction;
27                         continue L1;
28                     }
29                 }
30                 left = right;
31             }
32         }
33         array[left] = key;
34         quickSort(array, start, left - 1);
35         quickSort(array, left + 1, end);
36 
37     }

結果測試

1  @Test
2     public void testQuickSort() {
3         int[] array = new int[]{1, 3, 4, 10, 2, 5, 6, 9, 7, 8};
4         quickSort(array, 0, array.length - 1);
5         for (int i = 0; i < array.length; i++) {
6             System.out.println(array[i]);
7         }
8     }

結果打印

歸併排序

概述

歸併排序與快速排序相同，一樣是借鑑二叉樹的思想，時間複雜度O(n),與快速排序同樣是大量數據排序的最優方式之一。spa

思路分析

歸併排序是將目標數組分紅左右兩個數組，左右兩個數組必須是有序的，而後對這兩個數組合並從而實現排序。對於任意的數組均可以將全部的數據分紅若干個數組，每一個數組中都只有一個元素，而後兩兩合併。（所以，歸併排序的內存開銷會比快速排序多）指針

代碼實現

 1   private void mergeSort(int[] array, int left, int right) {
 2         if (left >= right) {
 3             return;
 4         }
 5         int mid = (left + right) >> 1;
 6         mergeSort(array, left, mid);
 7         mergeSort(array, mid + 1, right);
 8         merge(array, left, mid + 1, right);
 9     }
10 
11     private void merge(int[] array, int left, int mid, int right) {
12         int leftSize = mid - left;
13         int rightSize = right - mid + 1;
14         int[] leftArray = new int[leftSize];
15         int[] rightArray = new int[rightSize];
16         System.arraycopy(array, left, leftArray, 0, leftSize);
17         System.arraycopy(array, mid, rightArray, 0, rightSize);
18         int index=left;
19         int leftIndex = 0;
20         int rightIndex = 0;
21         while (leftIndex<leftSize&&rightIndex<rightSize){
22             if(leftArray[leftIndex]<rightArray[rightIndex]){
23                 array[index++] = leftArray[leftIndex++];
24             }else {
25                 array[index++] = rightArray[rightIndex++];
26             }
27         }
28         while (leftIndex<leftSize){
29             array[index++] = leftArray[leftIndex++];
30         }
31         while (rightIndex<rightSize){
32             array[index++] = rightArray[rightIndex++];
33         }
34     }

測試代碼

1  @Test
2     public void testMergeSort() {
3         int[] array = new int[]{1, 3, 4, 10, 2, 5, 6, 9, 7, 8};
4         mergeSort(array, 0, array.length - 1);
5         for (int i = 0; i < array.length; i++) {
6             System.out.println(array[i]);
7         }
8     }

結果打印