冒泡排序法

存在数组 arr = [ 25, 93, 47, 64, 34 ] , 以从小到大排序为例。

思路

共进行 arr.length-1 轮排序，每轮排序完成后，达到将第 i 大的元素，放在倒数第 i 个位置上的效果。

• 第一轮排序：达到将第1大的元素93放在倒数第1个位置上的效果，即 [ 25, 47, 64, 34, 93 ]；

        为达到该效果，从前往后将相邻元素进行逐一比较，每次都将较大的元素往后交换。从 i =0 到 i = arr.lenghth -1 遍历，比较 arr[i] 和 arr[i+1]，若 arr[i]> arr[i+1]， 则交换两个元素的位置。

               arr =  [ 25, 93, 47, 64, 34 ]；

                第0次比较，25 和 93，不发生交换；

                第1次比较，93 和 47，发生交换，交换后数组为 [25, 47, 93, 64, 34 ]；

                第2次比较，93 和 64，发生交换，交换后数组为 [25, 47, 64, 93, 34 ]；

                第3次比较，93 和 34，发生交换，交换后数组为 [25, 47, 64, 34, 93 ]；

• 第二轮排序，达到将第2大的元素64放在倒数第2个位置上的效果，即 [ 25, 47, 34, 64, 93 ];

        经过第一轮排序后， arr =  [25, 47, 64, 34, 93 ] ，最大元素已归位，因此只需要对 i = 0 到 i = arr.length -1 -1 进行遍历比较相邻元素。

                第0次比较，25 和 47，不发生交换；

                第1次比较，47 和 64， 不发生交换；

                第2次比较，64 和 34， 发生交换，交换后数组为  [25, 47, 34, 64, 93 ];

• 第三轮排序，达到将第3大的元素47放在倒数第3个位置上的效果，即 [ 25, 34, 47, 64, 93 ];

        同理，经过第二轮排序后， arr = [25, 47, 34, 64, 93 ] ，倒数1、2位置上的元素已归位，因此第三轮只需要对 i = 0 到 i = arr.length -1 -2 进行遍历比较相邻元素。    

                第0次比较，25 和 47，不发生交换；

                第1次比较，47 和 34，发生交换，交换后数组为  [25, 34, 47, 64, 93 ]；

• 第四轮排序：

                第0次比较，25 和 34，不发生交换；

• 完成，即最终数组为 [25, 34, 47, 64, 93 ] 。

总结冒泡排序特点：

1. 例子中一共有5个元素
2. 一共进行了4轮排序，可以看成是外层循环
3. 第 i 轮循环确定第 i 大的数的位置
4. 当进行相邻比较时，如果前面的数大于后面的数，则交换两个数的位置
5. 每轮排序里的比较数在减少，因为每一轮排序确认的数的在后续就不需要参与比较了

Java代码实现

public class BubbleSort 
{
    public static void main(String[] args)
    {
        int [] arr = {25, 93, 47, 64, 34};
        BubbleSort B = new BubbleSort();
        arr  = B.bubbleSort(arr);
        for (int i = 0; i < arr.length; i++)
            System.out.println(arr[i]);
    }

    public int[] bubbleSort(int[] arr)
    {
        int temp = 0; //由于辅助两个变量进行交换
        for(int i = 0; i < arr.length-1; i++) // 外层循环，排序
        {
            for(int j = 0; j < arr.length-i-1; j++) // 内层循环，相邻元素进行比较
            {
                if (arr[j] > arr[j + 1])  // 交换
                {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }
}

以上是使用冒泡排序法实现从小到大排序。

以此类推，当需要实现从大到小排序时，外层循环将数组从后往前遍历；内层循环每次比较相邻的元素时，将大的元素往前放即可。