插入排序合并排序堆排序和快速排序

Posted 2020-11-18 hunrry

  1 * 插入排序
  2 * 时间复杂度O(n2)
  3 * @param array原地排序算法
  4 */
  5 public void insertSort(int[] array) {
  6 　　for (int i = 1; i < array.length; i++) {
  7 　　　　int present = array[i];
  8 　　　　int position = i;
  9 　　　　while (position > 0 &;&; array[position - 1] > present) {// 右移
 10　　　　　　 array[position] = array[position - 1];
 11　　　　　　 position--;
 12 　　　　　　}
 13 　　　　array[position] = present;
 14 　　}
 15 }
 16 
 17  
 18 
 19 /**
 20 
 21 * 合并排序
 22 * O(nlogn)
 23 * @param array
 24 * @param left 第一个索引
 25 * @param right 最后一个索引
 26 */
 27 public void mergeSort(int []array,int left,int right){
 28 　　if(left<right){
 29 　　　　int middle=(left+right)/2;
 30 　　　　mergeSort(array,left,middle);
 31　　　　 mergeSort(array,middle+1,right);
 32 　　　　merge(array,left,middle,right);
 33 　　}
 34 }
 35 
 36 public void merge(int []array,int left,int middle,int right){
 37 　　int [] array1=new int[middle-left+1];
 38 　　int [] array2=new int[right-middle];
 39 　　for(int i=0;i<array1.length;i++){
 40 　　　　array1[i]=array[left+i];
 41 　　}
 42 　　for(int i=0;i<array2.length;i++){
 43 　　　　array2[i]=array[middle+i+1];
 44 　　}
 45 　　int l=0,r=0,k=left;
 46 　　for(;k<=right&;&;l<array1.length&;&;r<array2.length;k++){
 47 　　　　if(array1[l]>array2[r]){
 48 　　　　　　array[k]=array2[r];
 49　　　　　　 r++;
 50 　　　　}else {
 51 　　　　　　array[k]=array1[l];
 52　　　　　　 l++;
 53 　　　　}
 54 　　}
 55 　　while(l<array1.length){
 56 　　　　array[k]=array1[l];
 57 　　　　　　l++;
 58 　　　　　　k++;
 59 　　　　}
 60　　　 while(r<array2.length){
 61 　　　　array[k]=array2[r];
 62 　　　　r++;
 63 　　　　k++;
 64 　　　}
 65 }
 66 
 67  
 68 
 69 /**
 70 * 堆排序
 71 * 原地排序且O(nlogn)
 72 * @param array
 73 */
 74 public void heapSort(int [] array){
 75 　　buildHeap(array);
 76 　　for(int i=array.length-1;i>0;i--){
 77 　　　　int k=array[0];
 78 　　　　array[0]=array[i];
 79 　　　　array[i]=k;
 80 　　　　heapify(array, 0, i);
 81 　　}
 82 }
 83 /**
 84 * 构建最大堆
 85 * @param array
 86 */
 87 public void buildHeap(int [] array){
 88 　　for(int i=array.length/2-1;i>-1;i--){
 89 　　　　heapify(array,i,array.length);
 90 　　}
 91 }
 92 
 93 /**
 94 * 
 95 * @param array 数组
 96 * @param index 数组中的索引
 97 * @param length 树中元素个数
 98 */
 99 public void heapify(int [] array,int index,int length){
100 　　int present=index;//当前索引
101 　　int value=array[index];
102 　　int largest=array[index];
103 　　int largest_index=index;
104 　　while((2*present+1)<length){//判断是否有儿子
105 　　　　if(array[2*present+1]>largest){
106 　　　　largest=array[2*present+1];
107 　　　　largest_index=2*present+1;
108 　　}
109 　　if((2*present+2)<length&;&;array[2*present+2]>largest){
110 　　　　largest=array[2*present+2];
111 　　　　largest_index=2*present+2;
112 　　}
113 　　if(largest_index!=present){
114 　　　　array[present]=largest;
115 　　　　present=largest_index;
116 　　　　largest=value;
117 　　}else{
118 　　　　break;
119 　　}
120 　　}
121 　　array[present]=value;
122}
123 
124  
125 
126 /**
127 * 最坏时间O(n2)----在数组已经排好序时发生
128 * O(nlogn)
129 * @param array
130 * @param p
131 * @param r
132 */
133 public void quickSort(int []array,int p,int r){
134 　　if(p<r){
135 　　　　int q=partition(array,p,r);
136 　　　　quickSort(array,p,q-1);
137 　　　　quickSort(array,q+1,r);
138 　　}
139 }
140 
141 public int partition(int []array,int p,int r){
142 　　Random random=new Random();
143 　　exchange(array,r,random.nextInt(r-p+1)+p);//随机取数
144 　　int x=array[r];
145 　　int i=p-1;
146 　　for(int j=p;j<r;j++){
147 　　　　if(array[j]<=x){
148 　　　　i=i+1;
149 　　　　exchange(array,i,j);
150 　　}
151 }
152 　　exchange(array,i+1,r);
153 　　return i+1;
154 }
155 
156 public void exchange(int []array,int p,int q){
157 　　int k=array[p];
158 　　array[p]=array[q];
159 　　array[q]=k;
160 }