排序算法：冒泡排序

1. 基本思想

冒泡排序算法是把较小的元素往前调或者把较大的元素往后调。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2. Java实现

    /*
     *  冒泡排序
     */
    public static void bubbleSort(int[] arr)
    {
        for (int i = 0; i < arr.length - 1; i++)
        {
            for (int j = 0; j < arr.length - 1 - i; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

测试：

    public static void main(String[] args)
    {
        int[] arr = {10, 9, 11, 50, 55, 1, 60, 65, 5, 15, 30, 20};
        System.out.print("排序前：");
        for (int i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + " ");
        }
        System.out.print("\n");
        bubbleSort(arr);
        System.out.print("排序后：");
        for (int i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + " ");
        }
    }

测试结果：

排序前：10 9 11 50 55 1 60 65 5 15 30 20 
排序后：1 5 9 10 11 15 20 30 50 55 60 65 

3. 算法分析 

第1轮排序后：9 10 11 50 1 55 60 5 15 30 20 65 
第2轮排序后：9 10 11 1 50 55 5 15 30 20 60 65 
第3轮排序后：9 10 1 11 50 5 15 30 20 55 60 65 
第4轮排序后：9 1 10 11 5 15 30 20 50 55 60 65 
第5轮排序后：1 9 10 5 11 15 20 30 50 55 60 65 
第6轮排序后：1 9 5 10 11 15 20 30 50 55 60 65 
第7轮排序后：1 5 9 10 11 15 20 30 50 55 60 65 
第8轮排序后：1 5 9 10 11 15 20 30 50 55 60 65 
第9轮排序后：1 5 9 10 11 15 20 30 50 55 60 65 
第10轮排序后：1 5 9 10 11 15 20 30 50 55 60 65 
第11轮排序后：1 5 9 10 11 15 20 30 50 55 60 65 

冒泡排序法的比较方式由第一个元素开始，比较相邻元素大小，若大小顺便不对，则对调后再进行下一个元素的比较，如此扫描过一次之后，就可以确保最后一个元素是正确的顺便。接着再逐步进行第二次扫描，直到完成所有元素的排序关系为止。此排序算法的时间复杂度为O(n^2)。

4. 算法优化

从上面的分析中，可以看出在第7轮排序后，数组已经是正确的顺序了，可是程序还是继续执行。这是上面的冒泡排序算法的一个缺点，即不管数据是否已经排序完成都会执行 n(n-1)/2 次。可以通过在程序中加入判断来确定何时可以提前中断排序，又可以得到正确的排序数据，来提高执行效率。

优化的方法为：

    /*
     *  新的冒泡排序
     */
    public static void newbubbleSort(int[] arr)
    {
        for (int i = 0; i < arr.length - 1; i++)
        {
            int flag = 0;
            for (int j = 0; j < arr.length - 1 - i; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                    flag++;
                }
            }
            if (flag == 0)
            {
                break;
            }
            System.out.print("第" + (i + 1) + "轮排序后：");
            for (int k = 0; k < arr.length; k++)
            {
                System.out.print(arr[k] + " ");
            }
            System.out.println();
        }
    }

结果：

排序前：10 9 11 50 55 1 60 65 5 15 30 20 
第1轮排序后：9 10 11 50 1 55 60 5 15 30 20 65 
第2轮排序后：9 10 11 1 50 55 5 15 30 20 60 65 
第3轮排序后：9 10 1 11 50 5 15 30 20 55 60 65 
第4轮排序后：9 1 10 11 5 15 30 20 50 55 60 65 
第5轮排序后：1 9 10 5 11 15 20 30 50 55 60 65 
第6轮排序后：1 9 5 10 11 15 20 30 50 55 60 65 
第7轮排序后：1 5 9 10 11 15 20 30 50 55 60 65 
排序后：1 5 9 10 11 15 20 30 50 55 60 65

从以上的结果可以看出，在此排序方法中，只经历了7轮的排序后，程序就停止了。如果在数据量如果很大的话，就大大的提高了执行的效率。