冒泡排序的介绍，以及对二维数组进行排序

一、冒泡排序的简单介绍

冒泡排序（英语：Bubble Sort）又称为泡式排序，是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

具体步骤如下：

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

举一个一维数组的例子:
6, 9 , 1 , 2 , 7 这五个元素，实现从小到大的排序

第一轮排序：

• 目前顺序: 6 9 1 2 7
• 首先我们从左边第一个元素开始，第一个元素与第二个元素比较，即6和9，显然6比9小，不交换位置
• 接着第二个元素与第三个元素比较，即9和1 ，因为9比1大，所以需要交换两者的位置
• 交换后，顺序变为：6 1 9 2 7
• 接着第三个元素和第四个元素比较，即9和2比较，显然9比2大，所以交换它们的位置
• 交换后，顺序变为：6 1 2 9 7
• 第四个元素与第五个元素比较，即9和7，显然9比7大，交换它们的位置
• 交换后，顺序变为：6 1 2 7 9

经过第一轮排序后，我们发现，最大的元素我们已经找到了，并将其排在了最右边，即为9。显然，这还不够，因为所有元素还未按从小到大的顺序进行排序，所以我们要进行第二轮排序。

第二轮排序：

• 经过第一轮排序，目前顺序为:6 1 2 7 9
• 左边第一个元素与第二个元素比较，即6和1，显然6比1大，交换位置
• 交换后顺序为：1 6 2 7 9
• 第二个元素和第三个元素比较，即6和2，显然，交换它们的位置
• 交换后顺序为:1 2 6 7 9

这里我们比较幸运，只用了两轮就把顺序排好了，但实际上可能会需要更多轮的排序，才能将所有元素按规则排好。

最差情况：

• 假设有x个元素，咱们共要排x -1轮
• 第一轮比较x - 1次
• 第二轮比较x - 2次
• 第三轮比较x - 3次
• 。。。
• 最后一轮比较1次

大家可以多尝试几个例子，自个试着排序，就能发现上述规律。

具体代码如下:

package com.personal.test;

public class BubSort {
    public static void main(String[] args) {
        //定义一个一维数组
        int[] arr = {2, 0, -3, 10,1};
        //冒泡排序
        int temp; //用于元素交换
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if(arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        //遍历一下数组，看看排序后的结果
        System.out.println("=====排序后结果======");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

二、用冒泡排序对二维数组进行排序

方法一

将二维数组的元素依次遍历到一维数组中，而后用冒泡排序对一维数组进行排序，再将一维数组的元素遍历回二维数组即可。

方法二

1. 将二维数组的每一行进行冒泡排序
2. 将一行的尾元素与下一行的头元素比较，即一行的最大元素和一行的最小元素比较。如果最大元素比最小元素大，则交换它们的位置。
3. 重复上述过程，直至尾元素与头元素不再发生交换

举个例子：

3	7	1
2	3	1
10	2	3

第一轮排序:
对每一行都进行冒泡排序，结果如下:

1	3	7
1	2	3
2	3	10

每一行的尾元素与下一行的头元素比较。如果尾元素比头元素大，则交换,结果如下：

1	3	1
7	2	2
3	3	10

因为尾头元素发生了交换，则重复上述过程.

当尾头元素不再交换时，则说明二维数组的元素按顺序排好了

代码如下：

public class Test2 {
    public static void main(String[] args) {
        //创建一个二维数组
        int[][] arr = {{1, 10, 3}, {2, 9, 2}, {-1, 9, -8}, {11, 0, 7}};
        new ArrSort().sort(arr);

        //打印一下数组看看效果
        System.out.println("======排序结果======");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

/**
 * 该类完成对二维数组的排序
 */
class ArrSort {
    public void sort(int[][] arr) {
        do {
            int temp;//该变量用于实现数组元素的交换
            //最外层循环,遍历二维数组的每一行一维数组
            for (int i = 0; i < arr.length; i++) {
                //对每一行的一维数组进行冒泡排序
                for (int j = 0; j < arr[i].length - 1; j++) {
                    for (int k = 0; k < arr[i].length - 1 - j; k++) {
                        if (arr[i][k] > arr[i][k + 1]) {
                            temp = arr[i][k];
                            arr[i][k] = arr[i][k + 1];
                            arr[i][k + 1] = temp;
                        }
                    }

                }
            }

            //检测每一行最后的元素（最大值）与一下行的第一个元素（最小值）进行比较，如果不是小于或者等于，则调换
            int count = 0;//统计有无交换情况，若有的话则do while 循环不会停止
            for (int i = 0; i < arr.length - 1; i++) {
                if (arr[i][arr[i].length - 1] > arr[i + 1][0]) {
                    temp = arr[i][arr[i].length - 1];
                    arr[i][arr[i].length - 1] = arr[i + 1][0];
                    arr[i + 1][0] = temp;
                    count++;
                }
            }
            //没有发生交换,终止循环
            if (count == 0) {
                break;
            }
        } while (true);
    }

}

运行结果: