三大排序算法

merge sort

空间复杂度：O(n)（sort list是O(1））

时间复杂度为O(nlgn)

稳定性：稳定排序

先局部有序，再整体有序

 1 public class Solution {
 2     /**
 3      * @param A an integer array
 4      * @return void
 5      */
 6     public void sortIntegers(int[] A) {
 7         int[] temp = new int[A.length];
 8         mergeSort(A, 0, A.length - 1, temp);
 9     }
10     
11     public void mergeSort(int[] A, int start, int end, int[] temp) {
12         if (start >= end) {
13             return;
14         }
15         mergeSort(A, start, (start + end) / 2, temp);
16         mergeSort(A, (start + end) / 2 + 1, end, temp);
17         
18         merge(A, start, end, temp);
19     }
20     
21     public void merge(int[] A, int start, int end, int[] temp) {
22         int mid = (start + end) / 2;
23         int left = start;
24         int right = mid + 1;
25         int index = start;
26         
27         while (left <= mid && right <= end) {
28             if (A[left] <= A[right]) {
29                 temp[index++] = A[left++];
30             } else {
31                 temp[index++] = A[right++];
32             }
33         }
34         while (left <= mid) {
35             temp[index++] = A[left++];
36         }
37         while (right <= end) {
38             temp[index++] = A[right++];
39         }
40         for (int i = start; i <= end; i++) {
41             A[i] = temp[i];
42         }
43     }
44 }

View Code

 

 

quick sort

空间复杂度：O(1)的额外空间

时间复杂度：期望时间复杂度为O(nlgn)，最坏情况下时间复杂度为O(n^2)

稳定性：不稳定排序

先整体有序，再局部有序

 1 public class Solution {
 2     /**
 3      * @param A an integer array
 4      * @return void
 5      */
 6     public void sortIntegers(int[] A) {
 7         if (A == null || A.length == 0) {
 8             return;
 9         }
10         quickSort(A, 0, A.length - 1);
11     }
12     
13     public void quickSort(int[] A, int start, int end) {
14         if (start >= end) {
15             return;
16         }
17         int left = start;
18         int right = end;
19         int pivot = A[(start + end) / 2];
20         
21         while (left <= right) {
22             while (left <= right && A[left] < pivot) {
23                 left++;
24             }
25             while (left <= right && A[right] > pivot) {
26                 right--;
27             }
28             if (left <= right) {
29                 int tmp = A[left];
30                 A[left] = A[right];
31                 A[right] = tmp;
32                 left++;
33                 right--;
34             }
35         }
36         
37         quickSort(A, start, right);
38         quickSort(A, left, end);
39     }
40 }

View Code

 

 

heap sort

 

转载于:https://www.cnblogs.com/coldyan/p/6083453.html