冒泡排序法（BubbleSort）——交换类排序法(java实现)

冒泡排序法

从数组的第一个元素arr[0]开始，两两比较arr[0]与arr[0+1]，如果前面的数大于后面的数（arr[i]>arr[i+1]）,那么交换两个元素的位置，把大的数往后移动。这样依次经过一轮比较以后，最大的数将会被交换到最后的位置arr[arr.length-1]。
接下来进行下一轮的比较，此轮比较的次数较上一轮少一次，因为上一轮中的最大值已经排到最后面。以此进行循环，直到排序结束。
冒泡排序法的最坏时间复杂度和平均时间复杂度都为O（n²），最坏需要比较的次数为n(n-1)/2。

图解如下

数组排序前 7 23 12 4 33 21 2 17 13 9
第一轮排序 7 12 4 23 21 2 17 13 9 33
第二轮排序 7 4 12 21 2 17 13 9 23
第三轮排序 4 7 12 2 17 13 9 21
第四轮排序 4 7 2 12 13 9 17
第五轮排序 4 2 7 12 9 13
第六轮排序 2 4 7 9 12
第七轮排序 2 4 7 9
第八轮排序 2 4 7
第九轮排序 2 4

代码实现（java）

public class BubbleSort {

    public static void main(String[] args){
        int arr[] = {6,10,5,2,3,7,9,1};
        bubblesort(arr);
        pt(arr);
    }

    public static void bubblesort(int arr[]){
        for(int i = 0 ; i < arr.length-1 ; i++){   //将第i+1个最大值放到数组后面
            for(int j = 0 ; j < arr.length-i-1 ; j++){  //对相邻元素进行比较、取逆。
                if(arr[j] > arr[j+1]){
                    swap(arr,j,j+1);
                }

            }
        }
    }

    //封装交换位置方法。
    public static void swap(int arr[],int a , int b){

        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void pt(int arr[]){
        for(int a:arr)
            System.out.print(a+" ");
        System.out.println();
    }

    //有的同学可能会用这个函数进行交换，这个函数在C++中是可用的，而在Java中是无效的。
    /*
     原因：
     java中基本数据类型为值传递(pass in value)
     swap_error中的参数a与b是形参，调用此方法的arr[j],arr[j+1]为实参
     调用此方法后，实参将值传递给形参a,b  由形参a,b再进行值的互换。
     由于是不是引用传递而是值传递，在调用此方法后，其arr[j],arr[j+1]实际并没有发生变化。
     */
    public static void swap_error(int a , int b){
        int temp = a;
        a = b; 
        b = temp;
    }

}
//Think Big, Think Long