数组排序

1.冒泡排序

 

 1     /**
 2      * @冒泡排序
 3      */
 4     public static void main(String[] args) {
 5         int array [] = {11,88,43,36,27,3,92,76,25,64};
 6         // 排序前
 7         for (int i = 0; i < array.length; i++) {
 8             System.out.print(array[i]);
 9             if (i != array.length - 1) {
10                 System.out.print(",");
11             }
12         }
13         System.out.println();
14         int tmp = 0;
15         // 冒泡排序的思想：
16         // 相邻两个数进行比较，较大的那个靠右站
17         // 第一层循环控制总的循环次数
18         for (int i = array.length - 1; i >= 0 ; i--) {
19             // 第一层每循环一次，i位置上的数肯定是i之前数中最大的一个
20             // 所以第二层循环的终点设到i即可，i之后的数不用再重复排序
21             for (int j = 0; j < i; j++) {
22                 if (array[j] > array[j+1]) {
23                     // 核心：将小的数组元素替换，排到前面
24                     tmp = array[j+1];
25                     array[j+1] = array[j];
26                     array[j] = tmp;
27                 }
28             }
29         }
30         // 打印排序结果
31         for (int i = 0; i < array.length; i++) {
32             System.out.print(array[i]);
33             if (i != array.length - 1) {
34                 System.out.print(",");
35             }
36         }
37         // java.util.Arrays的sort方法
38         System.out.println();
39         int array2 [] = {11,88,43,36,27,3,92,76,25,64};
40         Arrays.sort(array2);
41         // 打印排序结果
42         for (int i = 0; i < array2.length; i++) {
43             System.out.print(array2[i]);
44             if (i != array2.length - 1) {
45                 System.out.print(",");
46             }
47         }
48 
49     }

 

2.选择排序

 

 1     /**
 2      * @选择排序
 3      */
 4     public static void main(String[] args) {
 5         int array [] = {11,88,43,36,27,3,92,76,25,64};
 6         // 排序前
 7         for (int i = 0; i < array.length; i++) {
 8             System.out.print(array[i]);
 9             if (i != array.length - 1) {
10                 System.out.print(",");
11             }
12         }
13         System.out.println();
14         // 选择排序的思想：
15         // 定义一个变量，保存数组中最小数的位置，然后交换
16         int indx = 0;
17         int tmp = 0;
18         // 第一层循环控制总的循环次数
19         for (int i = 0; i < array.length ; i++) {
20             indx = i;
21             for (int j = i; j < array.length; j++) {
22                 // 核心：找出最小元素的位置
23                 if (array[indx] > array[j]) {
24                     indx = j;
25                 }
26             }
27             // 交换
28             tmp = array[i];
29             array[i] = array[indx];
30             array[indx] = tmp;
31         }
32 
33         // 打印排序结果
34         for (int i = 0; i < array.length; i++) {
35             System.out.print(array[i]);
36             if (i != array.length - 1) {
37                 System.out.print(",");
38             }
39         }
40 
41         // java.util.Arrays的sort方法
42         System.out.println();
43         int array2 [] = {11,88,43,36,27,3,92,76,25,64};
44         Arrays.sort(array2);
45         // 打印排序结果
46         for (int i = 0; i < array2.length; i++) {
47             System.out.print(array2[i]);
48             if (i != array2.length - 1) {
49                 System.out.print(",");
50             }
51         }
52 
53     }

 

3.快速排序

 

 1     /**
 2      * 快速排序
 3      */
 4     private static void quickSort(int[] array, int left, int right){
 5         if (left <= right - 1) {
 6             // 划分算法取出中间坐标
 7             int middle = getMiddle(array, left, right);
 8             // 以中间坐标为分界线，对左端进行排序
 9             quickSort(array, left, middle - 1);
10             // 以中间坐标为分界线，对右端进行排序
11             quickSort(array, middle + 1, right);
12         }
13     }
14     // 划分算法
15     // 把《left->right》区间内的数进行排序
16     // 首先把array[left]作为基点
17     // 从该区间的右端开始往前扫描，如果遇到比基点的值大的数则，右区间减一
18     // 如果遇到比基点值小的数，则交换位置，然后再从左边往右扫描
19     // 最后的直到left = right 为止
20     // 结果是以基点为中心，左边的比基点小，右边的比基点大
21     private static int getMiddle(int[] array, int left, int right) {
22         int middle = array[left];
23         int tmp = 0;
24         // 循环结束条件
25         while (left < right) {
26             // 先从右端开始扫，只要比基点值大，则pass
27             while (left < right && array[right] >= middle) {
28                 right --;
29             }
30             // 如果比基点值小，则交换
31             tmp = array[right];
32             array[right] = array[left];
33             array[left] = tmp;
34             // 从左边再扫，只要比基点值小，则pass
35             while (left < right && array[left] <= middle){
36                 left ++;
37             }
38             // 如果比基点值大，则交换
39             tmp = array[right];
40             array[right] = array[left];
41             array[left] = tmp;
42         }
43         return left;
44     }
45     public static void main(String[] args) {
46         int array [] = {11,88,43,36,27,3,92,76,25,64};
47         // 排序前
48         for (int i = 0; i < array.length; i++) {
49             System.out.print(array[i]);
50             if (i != array.length - 1) {
51                 System.out.print(",");
52             }
53         }
54         System.out.println();
55         quickSort(array, 0, array.length - 1);
56         for (int i = 0; i < array.length; i++) {
57             System.out.print(array[i]);
58             if (i != array.length - 1) {
59                 System.out.print(",");
60             }
61         }
62         
63     }