冒泡排序算法 ：BubbleSort

java中的经典算法：冒泡排序算法

$. 可以理解成当你静止一杯可乐时，里面的CO2随着你的静止,由于不不易溶于水的性质，

　　　　且会以气泡的形式逐渐向上漂浮。越大的气泡上浮速度越快。

冒泡排序算法的原理于此相似。 每次进行相邻值之间的替换；

　　　　大的值（元素）排在小的值（元素）前面  ，或者小的值（元素） 排在大的值（元素）前面。

import java.util.Arrays;

/*
* 冒泡排序算法
* */
public class BubbleSort {

    public static void main(String[] args) {

        int[] arr = {1, 35, 64, 24, 7, 6, 8, 46, 3, 34}; //定义10个数
        for (int i = 0; i < arr.length - 1; i++) {  //控制多少次循环
            System.out.println("循环次数："+i);
            for (int j = 0; j < arr.length - i - 1; j++) {//每进行一次循环排序的次数
                if (arr[j] > arr[j + 1]) {     //替换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                System.out.println("排序次数："+ j);
            }
        }
        for (int num:arr){
            System.out.println(Arrays.asList(num));  //采用集合的方式更直观的看结果
        }

    }
}

外层for控制着循环次数，内层for控制每次循环所需要的排序次数。

共进行8次循环，每次排序的次数以此递减。

　　　　第九次因为只有一个元素无需排序，所以直接输出结果。所以只存在8次循环排序。

　　　　每循环一次排序当前相邻数大小关系。

 if (arr[j] > arr[j + 1]) {     //替换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }

　　使用temp相当于一个中介寄存。

传递方式如下：

在冒泡排序中，相邻大的元素（小的元素）替换小的元素（大的元素）。

下图为第一次排序的一个步骤。 

arr[0] < arr[1]不做变化

arr[1] < arr[2]:不做变化

arr[2] > arr[3]：替换

替换后的当前arr[2] = 24  arr[3] = 64

arr[3] > arr[4] : 替换

替换后的arr[3] = 7  arr[4] = 64

以此类推，大的值（元素）往前调，小的值（元素）往后调。

当循环到最后一次时，只有一个数，所以最后一次不需要循环， 所以 

i < arr.length - 1

 每循环一次一次进行排序时总是去除上次最后一个值，所以

j < arr.length - i - 1

 　　$对以上述算法进行重构，保证每个方法只做一件事。

import java.util.Arrays;

public class Bubble {

    /*
     * 排序方法
     * */
    public int[] sort(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {
                //根据比较方法传来的结果判断  true?
                if (compare(nums[j], nums[j + 1])) {
                    arrange(j, j + 1, nums);
                }
            }
        }
        return nums;
    }

    /*
     * 进行排列
     * */
    private void arrange(int beforeNum, int afterNum, int[] nums) {
        int temp;
        temp = nums[afterNum];
        nums[afterNum] = nums[beforeNum];
        nums[beforeNum] = temp;
    }

    /*
     * 比较方法
     * 除去最后一次为最大值（最小值）不再进行排序，每次递减
     * 根据大于向后走进行规定
     * */
    public boolean compare(int beforeNum, int afterNum) {
        return beforeNum > afterNum ? true : false;
    }

    public static void main(String[] args) {
        Bubble bubble = new Bubble();
        int[] nums = new int[]{13, 235, 46, 123, 576, 121, 56, 4, 23, 9, 7, 9};
        //排序
        System.out.println(Arrays.toString(bubble.sort(nums)));
    }
}