1 public class ChooseSort extends SortAbstract{
 2     public static void main(String[] args) {
 3         int[] a = {1,8,5,6,3,7,5,4,8,9,12,2};
 4         new ChooseSort().sort(a);
 5         for(int c : a){
 6             System.out.println(c);
 7         }
 8     }
 9
10     public  void sort(int[] array){
11         if(array.length == 0)return ;
12         for(int i=0;i<array.length-1;i++){
13             for(int j=i+1;j<array.length;j++){
14                 if(array[i]>array[j]){
15                     swap(array, i, j);
16                 }
17             }
18         }
19     }
20
21    public  static void swap(int[] array,int i,int j){
22         int temp = array[i];
23         array[i] = array[j];
24         array[j] = temp;
25     }
26 }

 1 public class QuickSort extends SortAbstract{
 2     public static void qSort(int[] num,int low,int high){
 3         if(low<high){
 4             int pivotloc = partition(num,low,high);
 5             qSort(num, low, pivotloc-1);
 6             qSort(num, pivotloc+1, high);
 7         }
 8     }
 9     public  void sort(int[] array){
10         qSort(array, 0, array.length-1);
11     }
12     public static int partition(int[] num,int low,int high){
13         int mid = num[low];
14         int pivotkey = num[low];
15         while(low<high){
16             while(low<high&&num[high]>=pivotkey){
17                 --high;
18             }
19             num[low] = num[high];
20             while(low<high&&num[low]<=pivotkey){
21                 ++low;
22             }
23             num[high]=num[low];
24         }
25         num[low] = mid;
26         return low;
27     }
28     /**
29      * @param args
30      */
31     public static void main(String[] args) {
32         // TODO Auto-generated method stub
33         int[] num = {9,18,-8,-6,-57,5,62,0};
34         qSort(num, 0, num.length-1);
35         for(int i=0;i<num.length;i++){
36             System.out.println(num[i]);
37         }
38     }
39
40 }

 1 public class HeapSort extends SortAbstract {
 2     public void sort(int[] array){
 3         if(array.length<=1){
 4             return;
 5         }
 6         int len = array.length;
 7         for(int i=len/2+1;i>=0;i--){//初始最大堆 无序数组，由最右一个非子节点开始。这里len/2 +1 没想明白
 8             maxHeapify(array, i, len);
 9         }
10         for(int i = len-1; i>0; i-- ){
11             swap(array, 0, i); //每次将堆根节点与尾部交换，然后逻辑上数组放弃掉尾部，实际有点像尾部冒泡
12             maxHeapify(array, 0, --len); //从顶部开始顶堆调整
13         }
14     }
15     public static int getLeft(int index){
16         return index*2+1;
17     }
18     public static int getRight(int index){
19         return (index+1)*2;
20     }
21     public static void swap(int[] array, int i, int j){
22         int temp = array[i];
23         array[i] = array[j];
24         array[j] = temp;
25     }
26     public static void maxHeapify(int[] array, int index, int len){
27         if(array.length==0 || len<=1){
28             return;
29         }
30         int largest;
31         int left = getLeft(index);
32         int right = getRight(index);
33         if(left<len&&array[index]<array[left]){
34             largest = left;
35         }else{
36             largest = index;
37         }
38         if(right<len && array[right]>array[largest]){
39             largest = right;
40         }
41         if(largest!=index){
42             swap(array, largest, index); //交换两个位置的元素，并递归调用调整交换的孩子节点
43             maxHeapify(array, largest, len);
44         }
45     }
46     public static void main(String[] args){
47         int[] a = {1,8,5,6,3,7,5,4,8,9,12,2};
48         new HeapSort().sort(a);
49         for(int c : a){
50             System.out.println(c);
51         }
52     }
53 }