Java学习笔记——排序算法之O(n²)排序

男儿何不带吴钩，收取关山五十州。请君暂上凌烟阁，若个书生万户侯？

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——南园十三首

三种排序法：

1、冒泡法

2、简单选择法

3、直接插入法

上代码：

1、冒泡排序

 1 public class BubbleSort {
 2
 3     //最简单的排序，从0开始逐个对比往上冒
 4     public static void bubbleSort(int[] arr) {
 5         for (int i = 0; i < arr.length-1; i++) {
 6             for (int j = i+1; j < arr.length; j++) {
 7                 if (arr[i]>arr[j]) {
 8                     arr[i] = arr[i]^arr[j];
 9                     arr[j] = arr[i]^arr[j];
10                     arr[i] = arr[i]^arr[j];
11                 }
12             }
13         }
14     }
15     //正宗冒泡，正向
16     public static void bubbleSortA(int[] arr) {
17         for (int i = 0; i < arr.length-1; i++) {
18             for (int j = 0; j < arr.length-i-1; j++) {
19                 if (arr[j]>arr[j+1]) {
20                     arr[j] = arr[j]^arr[j+1];
21                     arr[j+1] = arr[j]^arr[j+1];
22                     arr[j] = arr[j]^arr[j+1];
23                 }
24             }
25         }
26     }
27     //反向
28     public static void bubbleSortB(int[] arr) {
29         for (int i = 0; i < arr.length-1; i++) {
30             for (int j = arr.length-1; j > i; j--) {
31                 if (arr[j-1]>arr[j]) {
32                     arr[j] = arr[j]^arr[j-1];
33                     arr[j-1] = arr[j]^arr[j-1];
34                     arr[j] = arr[j]^arr[j-1];
35                 }
36             }
37         }
38     }
39     //优化冒泡
40     public static void bubbleSortA0(int[] arr) {
41         boolean flag = true;
42         for (int i = 0; i < arr.length-1 && flag; i++) {
43             flag = false;
44             for (int j = arr.length-1; j > i; j--) {
45                 if (arr[j-1]>arr[j]) {
46                     arr[j] = arr[j]^arr[j-1];
47                     arr[j-1] = arr[j]^arr[j-1];
48                     arr[j] = arr[j]^arr[j-1];
49                     flag = true;//若没有发生交换，说明每对的前一位都不比后一位更大。无需再次排序
50                 }
51             }
52         }
53     }
54 }

2、简单选择排序，跟冒泡第一个思路差不多。区别在于不是每次都交换，而是记录最值的下标位置，每趟的最后交换

 1 public class SimpleSelectSort {
 2
 3     //简单冒泡的升级版，内外层循环不变，赋值n次，交换一次
 4     public static void simpleSelectSort(int[] arr){
 5         int min;
 6         for (int i = 0; i < arr.length-1; i++) {
 7             min = i;
 8             for (int j = i+1; j < arr.length; j++) {
 9                 if (arr[min] > arr[j]) {
10                     min = j;
11                 }
12             }
13             if (min != i) {
14                 arr[min] = arr[min] ^ arr[i];
15                 arr[i] = arr[min] ^ arr[i];
16                 arr[min] = arr[min] ^ arr[i];
17             }
18         }
19     }
20 }

3、直接插入法，这个思路就很好了，类似于捋牌。

 1 public class StraightInsertionSort {
 2
 3     //该方法从第二位开始取出，如果比前面小插入，前面的后移，想象理牌5,3,4,6,2，同花顺
 4     public static void straightinsertionsort(int[] arr){
 5         int temp;
 6         for (int i = 1,j = 0; i < arr.length; i++) {
 7             if (arr[i]<arr[i-1]) {
 8                 temp = arr[i];//取出牌
 9                 j = i-1;//给内层循环赋初值
10                 while (j>=0 && arr[j] > temp) {
11                     arr[j+1] = arr[j];//比牌大的后移
12                     j--;
13                 }
14                 arr[j+1] = temp;//插入牌
15             }
16         }
17     }
18 }