java数组排序方法

冒泡排序

冒泡排序（Bubble Sort）是常用的数组排序算法之一，它以简洁的思想与实现方法而备受青睐，也是广大学习者最先接触的一种排序算法。

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

冒泡排序的算法比较简单，排序的结果稳定，但时间效率不太高。Java 中的冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

例 1

获取用户在控制台输入的 5 个成绩信息，将这些成绩保存到数组中，然后对数组应用冒泡排序，并输出排序后的结果，实现步骤如下。

(1) 创建一个 Test24 类文件，在 main() 方法中开始编码。首先创建 Scanner 类的实例后声明 double 类型的 score 数组，然后接收用户在控制台输入的成绩，并保存到元素中。代码如下：

1. public static void main(String[] args) {
2. Scanner scan = new Scanner(System.in);
3. double[] score = new double[5];
4. for (int i = 0; i < score.length; i++) {
5. System.out.print("请输入第 " + (i + 1) + " 个成绩：");
6. score[i] = scan.nextDouble();
7. }
8. }

(2) 在对 score 数组排序之前，首先输出数组中各个元素的值。代码如下：

1. System.out.println("排序前的元素值：");
2. for(double val:score) {
3. System.out.print(val+"\t");
4. }
5. System.out.println();

(3) 通过冒泡排序方法实现对 score 数组的排序，在实现时需要借助一个临时变量。代码如下：

1. public static void main(String[] args) {
2. System.out.println("通过冒泡排序方法对数组进行排序：");
3. for (int i = 0; i < score.length - 1; i++) {
4. // 比较相邻两个元素，较大的数往后冒泡
5. for (int j = 0; j < score.length - 1 - i; j++) {
6. if (score[j] > score[j + 1]) {
7. double temp = score[j + 1]; // 把第一个元素值保存到临时变量中
8. score[j + 1] = score[j]; // 把第二个元素值转移到第一个元素变量中
9. score[j] = temp; // 把临时变量（第一个元素的原值）保存到第二个元素中
10. }
11. System.out.print(score[j] + " "); // 对排序后的数组元素进行输出
12. }
13. System.out.print("【");
14. for (int j = score.length - 1 - i; j < score.length; j++) {
15. System.out.print(score[j] + " ");
16. }
17. System.out.println("】");
18. }
19. }

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进，是一种排序执行效率很高的排序算法。

快速排序的基本思想是：通过一趟排序，将要排序的数据分隔成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据变成有序序列。

具体做法是：假设要对某个数组进行排序，首先需要任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它的前面，所有比它大的数都放到它的后面。这个过程称为一趟快速排序；递归调用此过程，即可实现数据的快速排序。

例 1

利用快速排序法对一数组进行排序，实现步骤如下。

(1) 声明静态的 getMiddle() 方法，该方法需要返回一个 int 类型的参数值，在该方法中传入 3 个参数。代码如下：

1. public static int getMiddle(int[] list, int low, int high) {
2. int tmp = list[low]; // 数组的第一个值作为中轴（分界点或关键数据）
3. while (low < high) {
4. while (low < high && list[high] > tmp) {
5. high--;
6. }
7. list[low] = list[high]; // 比中轴小的记录移到低端
8. while (low < high && list[low] < tmp) {
9. low++;
10. }
11. list[high] = list[low]; // 比中轴大的记录移到高端
12. }
13. list[low] = tmp; // 中轴记录到尾
14. return low; // 返回中轴的位置
15. }

(2) 创建静态的 unckSort() 方法，在该方法中判断 low 参数是否小于 high 参数，如果是则调用 getMiddle() 方法，将数组一分为二，并且调用自身的方法进行递归排序。代码如下：

1. public static void unckSort(int[] list,int low,int high) {
2. if(low < high) {
3. int middle = getMiddle(list,low,high); // 将list数组一分为二
4. unckSort(list,low,middle-1); // 对低字表进行递归排序
5. unckSort(list,middle+1,high); // 对高字表进行递归排序
6. }
7. }

(3) 声明静态的 quick() 方法，在该方法中判断传入的数组是否为空，如果不为空，则调用 unckSort() 方法进行排序。代码如下：

1. public static void quick(int[] str) {
2. if(str.length > 0) {
3. // 查看数组是否为空
4. unckSort(str,0,str.length-1);
5. }
6. }

(4) 在 main() 方法中声明 int 类型的 number 数组，接着输出该数组中的元素。然后调用自定义的 quick() 方法进行排序，排序后重新输出数组中的元素。代码如下：

1. int[] number={13,15,24,99,14,11,1,2,3};
2. System.out.println("排序前：");
3. for(int val:number) {
4. System.out.print(val+" ");
5. }
6. quick(number);
7. System.out.println("\n排序后：");
8. for(int val:number) {
9. System.out.print(val +" ");
10. }

直接插入排序

直接插入排序的基本思想是：将 n 个有序数存放在数组 a 中，要插入的数为 x，首先确定 x 插在数组中的位置 p，然后将 p 之后的元素都向后移一个位置，空出 a(p)，将 x 放入 a(p)，这样可实现插入 x 后仍然有序。

例 1

本例子通过直接插入的方法对上述例子中的 number 数组进行排序。创建一个 Test27 类文件，在 main() 方法中开始编码，具体实现代码如下：

1. public static void main(String[] args) {
2. int[] number = { 13, 15, 24, 99, 4, 1 };
3. System.out.println("排序前：");
4. for (int val : number) { // 遍历数组元素
5. System.out.print(val + " "); // 输出数组元素
6. }
7. int temp, j;
8. for (int i = 1; i < number.length; i++) {
9. temp = number[i];
10. for (j = i - 1; j >= 0 && number[j] > temp; j--) {
11. number[j + 1] = number[j];
12. }
13. number[j + 1] = temp;
14. }
15. System.out.println("\n排序后：");
16. for (int val : number) { // 遍历数组元素
17. System.out.print(val + " "); // 输出数组元素
18. }
19. }