冒泡排序

冒泡排序

import java.util.Arrays;


//冒泡排序
//1.比较数组中，两个相等的元素，如果第一个数比第二个数大，我们就交换他们的位置。
//2.每一次比较，都会产生出一个最大，或者最小的数字
//3.下一轮则可以少一次排序
//4.依次循环，直到结束


public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {3,4,5,88,9,12,145,1,999,6};

        int[] b =sort(a);   //调用完我们自己写的排序方法以后，返回一个排序后的数组

        System.out.println(Arrays.toString(b));

    }

    /**
     *   22  28   12   8   10   19
     *   22  12   28   8   10   19
     *   22  12   8    28  10   19
     *   22  12   8    10  28   19
     *   22  12   8    10  19   28
     *   12  22   8    10  19   28
     *   12  8    22   10  19   28
     *   12  8    10   22  19   28
     *   12  8    10   19  22   28
     *   8   12   10   19  22   28
     *   8   10   12   19  22   28
     */

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {

            boolean flag = false;   //通过flag标识位减少没有意义的比较

            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j] > array[j+1]) {    //此处改成 <，就是从大到小排序   最小的放前面
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }

            //假设第i次循环时，flag变为了false，那么跳出循环，剩下的循环次数都不要继续了，优化的外层循环的循环次数。
            if (flag == false) {
                break;
            }
        }

        return array;
    }


}

此处flag的存在，进行了适当的优化。当某一次外层循环进行时，内层循环里相邻两个数不存在前者大于后者，那么就会执行if(flag == false)操作，会直接跳出外层循环，不会再进行后续的外层循环，直接输出结果。