冒泡排序

冒泡排序
  算法如其名,越小的元素会经由交换慢慢“浮”到序列的顶端.
原理:一次排序,通过相邻的两个元素的比较,将较小的元素交换的序列的首位.

举例说明

注意:选择将最小的元素交换到序列的首位或将最大的元素交换到序列的末位或者将最小的元素交换到序列的末位或者将最大的元素交换到序列的首位会导致
序列遍历的顺序以及判断条件的略微不同,但是原理是完全相同的.

举例中使用的是将最小的元素交换到序列的首位,故遍历顺序是从序列的末位遍历.更符合算法的名字,像气泡一样从底部浮到上面.

第一次冒泡:
原数组a={3,7,2,4}
4和2比较,4大,不需要交换,a={3,7,2,4}
2与7比较,2小,交换位置,a={3,2,7,4}
2与3比较,2小,交换位置,a={2,3,7,4}
第一次排序完毕
数组第1个元素确定
a={2,3,7,4}

第二次冒泡
a={2,3,7,4}
4和7比较,4小,交换位置,a={2,3,4,7}
4和3比较,4大,不需要交换,a={2,3,4,7}
第二次排序完毕
数组前2个元素确定
a={2,3,4,7}

第三次冒泡
a={2,3,4,7}
7和4比较,7大,不需要交换位置,a={2,3,4,7}
第三次排序完毕
数组前3个元素确定
a={2,3,4,7}

整体排序完毕
数组有序
a={2,3,4,7}

从例子中我们能看到有规律的几点
1:冒泡排序的排序次数是序列长度length-1
2:每一次排序的结束条件是比较到了上一次排序确定的边界.

    public static <T extends Comparable<? super T>> void bubbleSort(T[] arr) {
        int length = arr.length;
        // 遍历次数
        for (int time = 0; time < length; time++) {
            for (int start = length - 1; start > time + 1; start--) {
                if (arr[start].compareTo(arr[start - 1]) < 0) {
                    // 上移
                    T tmp = arr[start];
                    arr[start] = arr[start - 1];
                    arr[start - 1] = tmp;
                }
            }
        }
    }