经典排序之冒泡排序

冒泡排序算法的原理：

1.比较相邻的两个数，如果如果第一个比第二个大，就交换两个数，小的放前面，大的放后面。

2.每一对相邻的元素做相同的工作，从第一对到最后一对，这样最后的元素就是最大的数。

3.以上两步就完成了第一趟排序，把最大数的放在了最后。这样下一趟排序就不需要再比较最后一个元素了。

4.对越来越少的元素重复以上步骤，直到排序完成。

举例说明：需要排序的数组 int [ ] a = {6,23,15,3,1};

public class MyTest {
    public static void main(String[] args) {
        int[] a = {6, 23, 15, 3, 1};
        bubbleSort(a);
    }

    /**
     * 冒泡排序
     *
     * @param a
     */
    private static void bubbleSort(int[] a) {
        System.out.println("原数组：");
        printArray(a);
        for (int i = 1; i < a.length; i++) {
            System.out.println("第" + i + "趟排序：");
            for (int j = 0; j < a.length - i; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
                printArray(a);
            }
        }
    }

    /**
     * 打印数组
     *
     * @param a
     */
    private static void printArray(int[] a) {
        for (int i : a) {
            System.out.print(i + "\t");
        }
        System.out.println();
    }
} 

为了更好的理解冒泡排序的工作原理在代码里打印了排序的过程：

第1趟排序：

第一次排序：6和23比较，6小于23，不交换位置，结果：6  23  15  3  1

第二次排序：23和15比较，23大于15，交换位置，结果：6  15  23  3  1

第三次排序：23和3比较，23大于3，交换位置，结果：6  15  3  23  1

第四次排序：23和1比较，23大于1，交换位置，结果：6  15  3  1  23

至此，第一趟排序完成了，将最大的数排到了最后，之后重复比较步骤，就不需要再比较最后一个元素了。

第2趟排序：

第一次排序：6和15比较，6小于15，不交换位置，结果：6  15  3  1  23

第二次排序：15和3比较，15大于3，交换位置，结果：6  3  15  1  23

第三次排序：15和1比较，15大于1，交换位置，结果：6  3  1  15  23

第3趟排序：

第一次排序：6和3比较，6大于3，交换位置，结果：3  6  1  15  23

第二次排序：6和1比较，6大于1，交换位置，结果：3  1  6  15  23

第4趟排序：

第一次排序：3和1比较，3大于1，交换位置，结果：1  3  6  15  23

到这里排序就全部完成了，总结一下N个数字的排序，要进行N-1趟排序，每一趟找出最大值，所以每 i 趟的比较次数为 （N-i）次。优点是每趟都会减少一定的算法量。

这里只是简单的记录一下冒泡排序。