冒泡排序

第0个元素开始，依次比较相邻的两个元素，如果前面的元素大于后面的元素，那么将两个元素交换位置。
简单来说就是使用相邻的两个元素依次比较，依次将最大的数放到最后。
这种排序方式就像是将最大的元素一个气泡一样慢慢浮来，所以叫冒泡排序。
同一种排序的计算方式不因编程语言的不同而不同，本篇帖子以java为例：

int[] source = {8, 6, 10, 1, 2, 7, 3};// 要排序的数组

第0轮排序:

• 第一次：8与6比较，8>6,交换位置，得到 6, 8, 10, 1, 2, 7, 3
• 第二次，8与10比较，8<10,不用换位置，得到 6, 8, 10, 1, 2, 7, 3
• 第三次，10与1比较，10>1, 交换位置，得到 6, 8, 1, 10, 2, 7, 3
• 第四次，10与2比较，10>2, 交换位置，得到 6, 8, 1, 2, 10, 7, 3
• 第五次，10与7比较，10>7, 交换位置，得到 6, 8, 1, 2, 7, 10, 3
• 第六次，10与3比较，10>3, 交换位置，得到 6, 8, 1, 2, 7,3,10
  第0轮结束后，我们将数组总的最大元素冒泡到了数组的最后面。

第0轮代码实现：

//注意比较次数为source.length - 1次
 for (int i = 0; i < source.length - 1; i++) {
                //如果前面的元素大于后面的元素
                if (source[i] > source[i + 1]) {
                    //交换位置
                    int temp = source[i];
                    source[i] = source[i + 1];
                    source[i + 1] = temp;
                }
            }

这里面有个比较次数的问题，试想一下，比较两、2个元素的大小，那么需要比较1次，比较3个元素的大小，需要比较2次。比较N个元素的大小，则需要比较N-1次。

第1轮排序：此时的数据源已经变为6, 8, 1, 2, 7,3,10

在第0轮排序结束以后，我们得到了这样的结果：{6, 8, 1, 2, 7,3,10}，跟原来的数组{8, 6, 10, 1, 2, 7, 3}比较，我们发现数组中最大的数字移动到了数组的最右端，那么，在本轮比较中，10这个元素就不需要再参与比较了，所以本轮需要比较的元素从7个变成了6个，那么比较的次数也变成了5次，即第1轮需要比较的次数为n-1-1次。
比较过程如下：

• 第一次：6与8比较，6<8,不交换位置，得到 6, 8, 1, 2, 7,3,10
• 第二次，8与1比较，8>1,交换位置，得到 6, 1, 8, 2, 7,3,10
• 第三次，8与2比较，8>2, 交换位置，得到 6, 1, 2, 8, 7,3,10
• 第四次，8与7比较，8>7, 交换位置，得到 6, 1, 2,7,8,3,10
• 第五次，8与3比较，8>3, 交换位置，得到 6, 1, 2, 7, 3,8,10
  第1轮代码实现：

//注意本轮比较次数为source.length - 1-1次
 for (int i = 0; i < source.length - 1-1; i++) {
                //如果前面的元素大于后面的元素
                if (source[i] > source[i + 1]) {
                    //交换位置
                    int temp = source[i];
                    source[i] = source[i + 1];
                    source[i + 1] = temp;
                }
            }

第2轮排序推导过程与第0轮和第1轮相似

整个冒泡排序的代码实现：

/**
     * 冒泡排序
     */
    public void bubbleSort() {
        int[] source = {10, 6, 1, 8, 2, 7, 3};
        //外层，用于记录和控制第几轮循环
        for (int i = 0; i < source.length - 1; i++) {
            //内层，用于控制每轮循环的次数
            for (int j = 0; j < source.length - 1 - i; j++) {
                //如果前面的数大于后面的数，则交换位置
                if (source[j] > source[j + 1]) {
                    int temp = source[j];
                    source[j] = source[j + 1];
                    source[j + 1] = temp;
                }

            }
        }