排序算法之-冒泡排序

冒泡排序是常见的排序算法，就是不断的两两比较，如果左边的元素大于右边的，则交换位置，否则不交换。最终达到排序的目的。

public class MaoPaoTest {

    //这个是之前写的
    public static void sort(int[] array){
        //外层循环控制的是要循环多少次
        for(int i=0;i<array.length-1;i++) {
            //内层循环是两两比较，交换位置，已经排序好的元素不参与比较了。
            //所以是比较次数是array.length-1-i
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
            System.out.println("第"+i+"次外循环排序结果："+ Arrays.toString(array));
        }
    }

    //这个方法更好理解
    public static int[] sortNew(int[] nums){
        for(int i=0;i<nums.length-1;i++){
            for(int j=i+1;j<nums.length;j++){
                int a = nums[i];
                int b = nums[j];
                if(a > b){
                    nums[i] = b;
                    nums[j] = a;
                }
            }
        }
        return nums;
    }

    public static void main(String[] args) {
        int[] array = {9,6,5,4,2,1};
        sort(array);
        System.out.println("最终排序结果："+Arrays.toString(array));
    }
}

以数组{9,6,5,4,2,1}为例：

第0次外循环排序结果：[6, 5, 4, 2, 1, 9]   

交换位置5次，找出最大的数9，也就是9排序好了，下次外循环中，两两比较不参与了。

第1次外循环排序结果：[5, 4, 2, 1, 6, 9]   

交换位置4次，找出第二大的数6，也就是6，9排序好了，不再参与内层比较循环。

第2次外循环排序结果：[4, 2, 1, 5, 6, 9] 

 交换位置3次，找出第三大的数5，也就是5，6，9排序好了，不再参与内层比较循环。

第3次外循环排序结果：[2, 1, 4, 5, 6, 9] 

交换位置2次，找出第四大的数4，也就是4，5，6，9排序好了，不再参与内层比较循环。

第4次外循环排序结果：[1, 2, 4, 5, 6, 9] 

交换位置1次，找出第五大的数2，也就是2，4，5，6，9排序好了，不再参与内层比较循环。

最终排序结果：[1, 2, 4, 5, 6, 9]

每次外循环的结果就是：通过交换位置，找出还未排序数据最大的数。