入门算法之冒泡排序

一、冒泡排序的原理：
相邻的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换

例子：

int[] t = {9,0,1,2,8,5,6};

//内循环
从9开始第一次内循环：
第一次：9>0,9与0交换位置，数组t变成

int[] t = {0,9,1,2,8,5,6};

第二次：9>1,9 与1交换位置，数组t变成

int[] t = {0,1,9,2,8,5,6};

第三次：9>2,9与2交换位置，数组t变成

int[] t = {0,1,2,9,8,5,6};

第四次：9>8,9与8交换位置，数组t变成

int[] t = {0,1,2,8,9,5,6};

第五次：9>5,9与5交换位置，数组t变成

int[] t = {0,1,2,8,5,9,6};

第六次：9>6，9与6交换位置，数组t变成

int[] t = {0,1,2,8,5,6,9};

自此，第一次内循环就结束了，我们可以发现，数组t的长度为7，而内循环的次数为7-1=6

---

外循环

第二次，从0开始从左至右与相邻的数字比较，开始第二次内循环比较

第一次：0<1,0和1不发生交换，数组t变成

int[] t = {0,1,2,8,5,6,9};

第二次：1<2,1和2不发生交换，数组t变成

int[] t = {0,1,2,8,5,6,9};

第三次：2<8，2和8不发生交换，数组t变成

int[] t = {0,1,2,8,5,6,9};

第四次：8>5,8和5发生交换，数组t变成

int[] t = {0,1,2,5,8,6,9};

第五次，8>6，8和6发生交换，数组t变成

int[] t = {0,1,2,5,6,8,9};

第六次，8 <9，8和9不发生交换，数组t变成

int[] t = {0,1,2,5,6,8,9};

至此，第二次内循环结束，由于我写的数组例子不好，到此次循环，数组t已经从小打到排序结束，实际上，还是要进行第三次外循环，依旧从数组t的首位开始，依次相邻的两个相比，外循环的次数就等于数组的长度

——————————————————————————————- 总结：1、冒泡排序由两次组成，外循环次数为数组长度，内循环次数为数组长度-1

//以下由代码实现以上逻辑
public class Demo {

    public static void main(String[] args) {
        int[] t = { 9, 0, 1, 2, 8, 5, 6 };
        // 外循环
        for (int i = 0; i < t.length; i++) {
            for (int j = 0; j < t.length - 1; j++) {
                // 如果t[j]>t[j+1],则两两交换
                // 定义一个临时变量temp储存t[j]
                if (t[j] > t[j + 1]) {
                    int temp = t[j];
                    t[j] = t[j + 1];
                    t[j + 1] = temp;
                }
            }
        }
        // 输出排序后的数组t的结果
        for (int a = 0; a < t.length; a++) {
            System.out.println(t[a]);
        }

    }

}

输出结果：
0
1
2
5
6
8
9