排序算法原理及实现

插入排序

 1     public static void insertSort(Comparable[] array)
 2     {
 3         int j = 0;
 4         
 5         for (int i = 1; i < array.length; i++) {
 6             Comparable temp = array[i];
 7             
 8             for (j = i; j > 0 && (temp.compareTo(array[j - 1]) < 0); j--) {
 9                 array[j] = array[j - 1];
10             }
11             array[j] = temp;
12         }
13     }

 

 

归并排序

 1     public static void mergeSort(Comparable[] array)
 2     {
 3         Comparable[] copy = new Comparable[array.length];
 4         mergeSort(array, copy, 0, array.length - 1);
 5     }
 6     
 7     
 8     private static void mergeSort(Comparable[] array, Comparable[] temp, int left, int right)
 9     {
10         if (left < right) {
11             int middle = (left + right) >> 1;
12             mergeSort(array, temp, left, middle);
13             mergeSort(array, temp, middle + 1, right);
14             merge(array, temp, left, middle + 1, right);
15         }
16     }
17     
18     
19     private static void merge(Comparable[] array, Comparable[] temp, int left, int right, int rightEnd)
20     {
21         int leftEnd = right - 1;
22         int tempIdx = left;
23         int length  = rightEnd - left + 1;
24         
25         while (left <= leftEnd && right <= rightEnd) {
26             if (array[left].compareTo(array[right]) < 0) {
27                 temp[tempIdx++] = array[left++];
28             }
29             else {
30                 temp[tempIdx++] = array[right++];
31             }
32         }
33         
34         while (left <= leftEnd) {
35             temp[tempIdx++] = array[left++];
36         }
37         
38         while (right <= rightEnd) {
39             temp[tempIdx++] = array[right++];
40         }
41         
42         for (int i = 0; i <length; i++, rightEnd--) {
43             array[rightEnd] = temp[rightEnd];
44         }
45     }

 

快速排序

 1     public static void quickSort(Comparable[] array)
 2     {
 3         quickSort(array, 0, array.length - 1);
 4     }
 5     
 6     
 7     private static void quickSort(Comparable[] array, int left, int right)
 8     {
 9         if (left + 3 <= right) {
10             Comparable middle = just(array, left, right);
11             
12             int i = left, j = right - 1;
13             
14             for (;;) {
15                 while (array[++i].compareTo(middle) < 0) {}
16                 while (array[--j].compareTo(middle) > 0) {System.out.println(j);}
17                 if (i < j) swap(array, i, j); else break;
18             }
19             
20             swap(array, i, right - 1);
21             quickSort(array, left, i);
22             quickSort(array, i + 1, right);
23         }
24         else {
25             insertSort(array);
26         }
27     }
28     
29     
30     private static Comparable just(Comparable[] array, int left, int right)
31     {
32         int middle = (left + right) >> 1;
33                 
34         if (array[left].compareTo(array[middle]) > 0)  swap(array, left, middle);
35         if (array[middle].compareTo(array[right]) > 0) swap(array, middle, right);
36         if (array[right].compareTo(array[left]) > 0)   swap(array, left, right);
37         
38         swap(array, middle, right);
39         return array[right];
40     }
41     
42     
43     private static void swap(Comparable[] array, int i, int j)
44     {
45         Comparable tmp = array[i];
46         array[i] = array[j];
47         array[j] = tmp;
48     }

 

先放上代码，原理及注释随后补全

 

来源：https://www.cnblogs.com/rilley/archive/2012/07/02/2573310.html