1 package sort;
2
3 import java.util.ArrayList;
4 import java.util.Random;
5
6 public class Sort
7 {
8
9 public static Random r = new Random();
10
11 // public static transient ArrayList<String> arr = new
12 // ArrayList<String>();//动态 transient
13 // static int n;
14 // public static int a[] = new int [n];//静态的数组，n也必须要静态的才能行
15
16 // static long l = 88888l;
17 // static float f = 0.12f;
18 //
19 /**
20 * 堆排序，建立小顶堆。 0-len是待调整的数组，k指向该次被调整子树的根结点
21 */
22
23 public static void adjustDown(int arr[], int len, int k)
24 {
25 // f = l;
26 int temp = arr[k];
27
28 for (int i = 2 * k + 1; i <= len; i = 2 * i + 1)
29 {
30 // 只有右孩子存在，且右孩子又是小的结点，那么才会改变探索指针i的方向。（i一直指向待调整子树的孩子结点中值较小的结点，为了小顶堆的目标）
31 if (i < len && arr[i] > arr[i + 1])
32 {
33 i++;
34 }
35 if (temp <= arr[i])
36 {
37 break;
38 }
39 else
40 {
41 arr[k] = arr[i];
42 k = i;// k一直指向，待调整的子树 的父结点
43 }
44 }
45 arr[k] = temp;// 待调整的k指针没动，直接break出来，没有继续向下调整
46 }
47
48 // 堆排序，先要建立初始堆（从k到0位置，反复向下调整），然后拿出堆顶（对堆的删除），从根破坏了堆性质，又从根往下调整一次即可。
49 // 对堆的插入：新结点放在堆的末端，破坏了最下面子树的堆性质，故向上调整到某一次符合堆的性质即可
50 public static void heapSort(int arr[], int len)
51 {
52 // 这个循环建立了初始堆
53 for (int i = (len - 1) / 2; i >= 0; i--)
54 {
55
56 adjustDown(arr, len, i);
57 // Sort.disArr(arr);
58 }
59 int temp = 0;
60 for (int index = len; index >= 0;)
61 {
62 temp = arr[0];
63 arr[0] = arr[index];
64 arr[index] = temp;
65 // System.out.println(arr[index] + " ");
66 // Sort.disArr(arr);
67 index--;
68 adjustDown(arr, index, 0);// 固定从整个树的根开始向下调整
69 }
70
71 }
72
73 // 对小顶堆的插入，插入需要向上调整--AdjustUp
74 public static void insertHeap(int arr[], int k)
75 {
76
77 // k为插入结点的位置
78 int index = k;
79 int temp = arr[index];// n+1指向新放入的元素
80 while ((index - 1) / 2 >= 0 && temp < arr[(index - 1) / 2])
81 {
82 arr[index] = arr[(index - 1) / 2];// 插入的元素更小，就把父节点值放到子节点中去
83 index = (index - 1) / 2;// 默认父节点值与temp交换了，一直拿temp去和父辈，父辈的父辈……去比较
84 if (index == 0)
85 break;// 不要在根兜圈圈！减1除2，在0处就不动了；也不能写return ，temp的值还是要赋值回去的
86 }
87 arr[index] = temp;
88 }
89
90 // 利用向上调整，建立初始堆。
91 // 一边不断插入元素，一边自底（k）向上（0）调整一次。
92 public static void heapSort(int arr[])
93 {
94 // 用直接插入法的思维，一个个点插入堆中，利用向上调整，建立初始堆
95 for (int i = 0; i <= arr.length - 1; i++)
96 {
97 insertHeap(arr, i);
98 }
99
100 // 还是要用到向下调整，输出序列或进行排序，因为只有堆顶元素具有“最”的特性，输出堆顶元素，从顶破坏了堆的结构，自然需要向下调整。
101 int temp = 0;
102 for (int index = arr.length - 1; index >= 0;)
103 {
104 temp = arr[0];
105 arr[0] = arr[index];
106 arr[index] = temp;
107 // System.out.println(arr[index] + " ");
108 // Sort.disArr(arr);
109 index--;
110 adjustDown(arr, index, 0);
111 }
112 }
113
114 public static void selectSort(int a[])
115 {
116 int i = 0, j = 0;
117 // int restMin = 0;
118 int index = 0;
119 int temp = 0;
120 // 从第0个位置选定元素到第倒数第二个位置，最后只剩一个元素，就不用选定位置了
121 for (i = 0; i < a.length - 1; i++)
122 {
123 // restMin = a[i];//为找到最值做准备;剩下位置中的最小值
124 index = i;// 必须先初始化为当前位置,因为最值可能就是当前位置的元素嘛
125 // j指向待比较的元素
126 for (j = i + 1; j < a.length; j++)
127 {
128 // a[index]值是变化的，用index指向剩下位置中的最小值
129 if (a[j] < a[index])
130 {
131 // restMin = a[j];//restMin保存最小值
132 index = j;// 记录最值的位置，同时a[index]自然也记录了最值的大小
133 }
134 }
135 // swap 交换最小值和当前位置元素的值
136 if (index != i)
137 {
138 temp = a[i];
139 a[i] = a[index];
140 a[index] = temp;
141 }
142
143 }
144 }
145
146 // 合并段中，把mid位置的放前后和后段，会影响mid取值的计算，以及边界的控制。
147 public static void merge(int a[], int left, int mid, int right)
148 {
149 if (left >= right)
150 return;
151
152 int index1 = 0;// 游标指向合并中的一段[0 到 mid-left-1]，检测指针
153 int index2 = mid - left;// 游标指向合并中的另一段[mid-left- right - left]
154 int k = left;// 指向合并后序列的位置,存放指针
155
156 // 在a中取原数据， 在b上合并，再把最终结果保存回原来的数组a；或者copy数据到b，把合并后结果直接覆盖到a上
157 int b[] = new int[right - left + 1];
158
159 for (int i = 0; i < right - left + 1; i++)
160 {
161 b[i] = a[left + i];
162 }
163
164 while (index1 <= mid - left - 1 && index2 <= right - left)
165 {
166 if (b[index1] <= b[index2])
167 {
168 a[k++] = b[index1++];
169 }
170 else
171 {
172 a[k++] = b[index2++];
173 }
174 }
175
176 while (index1 <= mid - left - 1)
177 {
178 a[k++] = b[index1++];// 没有检测完的，复制
179 }
180 while (index2 <= right - left)
181 {
182 a[k++] = b[index2++];
183 }
184 }
185
186 public static void mergeSort(int a[], int left, int right)
187 {
188 if (left >= right)
189 return;
190 int mid = (left + right) / 2 + 1;
191 mergeSort(a, left, mid - 1);
192 mergeSort(a, mid, right);
193 merge(a, left, mid, right);
194
195 }
196
197 /**
198 *
199 * 交换排序之冒泡排序，结果升序排列
200 */
201 public static void bubbleSort(int a[])
202 {
203 int i = 0, j = 0, temp = 0;
204 boolean swaped = false;
205 for (i = 0; i < a.length; i++)
206 {
207 swaped = false;
208 // 会有j+1，所以注意边界控制
209 for (j = 0; j < a.length - i - 1; j++)
210 {
211 if (a[j] > a[j + 1])
212 {
213 temp = a[j];
214 a[j] = a[j + 1];
215 a[j + 1] = temp;
216 swaped = true;
217 }
218 }
219 if (swaped == false)
220 {
221 break;
222 }
223 }
224 }
225
226 /**
227 * 交换排序之快速排序
228 */
229
230 // public static int partition2(int a[], int left, int right)
231 // {
232 // // int index = left + r.nextInt(right-left+1);
233 // int value = a[left];
234 // // System.out.println(left + " -- " + right + " 基准元素是 : a[" +index +
235 // // "]=" + a[index]);
236 // while (left < right)
237 // {
238 // // 等于枢轴值的元素在轴的或左边或右边都没有关系，只要保证小于它的在左边，大于它的在右边
239 // while (a[left] <= value && left < right)
240 // left++;
241 //
242 // while (a[right] >= value && left < right)
243 // right--;
244 //
245 // if (left < right)
246 // {
247 // // swap前后两个元素；但是已经不能保证此时的下标值还在枢轴的两侧
248 // int temp = a[left];
249 // a[left] = a[right];
250 // a[right] = temp;
251 // left++;
252 // right--;
253 // }
254 // }
255 // // a[left] = value;
256 // Sort.disArr(a);
257 // System.out.println("本次枢轴值的最终位置（轴的位置）是： " + left);
258 // return left;
259 // }
260
261 public static int partition(int a[], int left, int right)
262 {
263 // 基准元素的选择对于快速排序性能影响较大；index
264 int index = left + r.nextInt(right - left + 1);// 随机选基准元素，把它放到a[left]哨兵位置，然后从right开始扫描，才是正确的
265 /**
266 * a[0]当哨兵，保证了，从后扫描，被调换元素一定再以该基准元素为轴的左侧！没调换，直接略过的元素，也一定是处于轴的右侧。
267 * 一定要从最两侧一步步逼近枢轴元素的最终位置
268 * 快速排序定位轴的位置，关键就看你是怎么把小于枢轴元素值的放到枢轴左边，大于枢轴元素值的放到枢轴右边
269 * ；用腾空一个位置的办法也好，有swap的想法也好
270 * ，你的代码是如何具体实现的呢？考虑使用双向链表，设置头指针和尾指针，（拔下结点）在头结点之前插入小的，在尾结点之后插入大的
271 */
272 // if(index > right || index < left)
273 // {
274 // System.out.println("ERROR index");
275 // }
276 // else
277 // {
278 // System.out.println(left + " -- " + right + " 基准元素是 : a[" +index +
279 // "]=" + a[index]);
280 // }
281 // int index = (left + right) / 2;
282 int value = a[index];// 用value保存了当前选取的枢轴元素，就可腾空一个位置
283
284 // 一定把枢轴元素交换至最左边（放到最左就从right开始检测，最右就应该从left开始检测），使得腾空的位置从最边上向枢轴的真正位置逼近！而不是一开始就从枢轴元素的起始位置开始移动
285
286 int temp = a[left];
287 a[left] = a[index];
288 a[index] = temp;
289
290 //
291 while (left < right)
292 {
293 // 比较中带等号，针对重复元素如：4，3，4，检测指针才会移动，不然就死循环了
294
295 // 先让右侧开始检测，对于4,9；选了9当value，直接开始right--就不对
296 while (left < right && a[right] >= value)
297 {
298 right--;
299 }
300 a[left] = a[right];
301 // index = right;
302 // if(left < right)
303 // {
304 // //这样需要比较一次left和right是否重合；与它自己的值和自己比较，指针移动一次；效果上没有改进
305 // left++;
306 // }
307 // left++;//错误。当left与right指针重合时，这句话执行就不对，强制的多加了一次！重合之前都是对的
308 while (left < right && a[left] <= value)
309 {
310 left++;
311 }
312 a[right] = a[left];
313 // index = left;
314 // if(left < right)
315 // {
316 // //这样需要比较一次left和right是否重合；与它自己的值和自己比较，指针移动一次；效果上没有改进
317 // right--;
318 // }
319 }
320 // 必然left==right了
321 a[left] = value;
322 // System.out.println(" 划分点(该元素最终位置)： " + left);
323 return left;
324 }
325
326 public static void quikSort(int a[], int left, int right)
327 {
328 if (left >= right)
329 return;
330 int p = partition(a, left, right);
331 quikSort(a, left, p - 1);
332 quikSort(a, p + 1, right);
333 }
334
335 /**
336 * 直接插入排序，结果为升序
337 *
338 * @param a
339 */
340 public static void insertSort(int a[])
341 {
342 int i = 0, j = 0, temp = 0;
343 for (i = 2; i <= a.length; i++)
344 {
345 a[0] = a[i];// a[0]是哨兵
346 // i指向带插入的元素，从第二个开始试探，如果比前一个小，就要插入；一定是跟前一个比，而不是a[i]与a[i+1]
347 if (a[i] < a[i - 1])
348 {
349 // 找到合适的插入位置，j指向已经有序的端;哨兵保证 最多j==1时， 一定会停下来
350 j = i - 1;
351 while (a[j] > a[0])
352 {
353 a[j + 1] = a[j];//后移，数组上实现的直接插入排序就是要大量移动元素，考虑单链表，从头往后比较并插入？例如：最小值就放尾结点，然后依次插入，链表里面就呈降序排列，从大到小链接起来。
354 j--;
355 }
356 a[j + 1] = a[0];
357 }
358 }
359 }
360
361 public static void disArr(int a[])
362 {
363 int i = 0;// java中，定义在for中的int i ，作用域就只在for中
364 for (i = 0; i < a.length - 1; i++)
365 {
366 System.out.print(a[i] + " ");
367 }
368 System.out.println(a[i]);
369 }
370
371 public static void main(String[] args)
372 {
373 int a[] = { 9, 14, 4, 46, 9, 10 };
374 // System.out.println(-1 / 2);//负0打印也是0
375 Sort.disArr(a);
376 // Sort.bubbleSort(a);
377 // Sort.quikSort(a, 0, a.length-1);
378 // Sort.mergeSort(a, 0, a.length - 1);
379 // Sort.selectSort(a);
380 // Sort.heapSort(a, a.length - 1);//建立小根堆，把小的放后面，在数组里面便是降序排列了。
381 Sort.heapSort(a);// 建立小根堆，把小的放后面，在数组里面便是降序排列了。
382 Sort.disArr(a);
383 // System.out.println(Integer.toHexString(15));//打印出来还是不会带16进制的0x前缀
384 // test(1);
385 // test(a[0]);
386 // test(Integer.valueOf(3));
387 // short i = -3;
388 // System.out.println( -3 >>> 1);
389 // System.out.println(-0x8000 < 0);
390 // System.out.print(Math.pow(2, 15));
391 }
392
393 // public static void test(int d)
394 // {
395 //
396 // System.out.println("int: " + d);
397 // }
398 //
399 // public static void test(double d)
400 // {
401 // System.out.println("double: " + d);
402 // }
403 //
404 // public static void test(Integer i)
405 // {
406 // System.out.println("Integer: " + i.intValue());
407 // }
408 }
时间： 2024-12-25 19:32:12