排序算法(I)冒泡排序

     冒泡排序（Bubble Sort），它重复地走访过要排序的元素，依次比较相邻两个元素，如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，

排序完成。这个算法的名字由来是因为越小(或越大)的元素会经由交换慢慢“浮”到数列的顶端   

      冒泡排序算法的运作如下：

• 比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数
• 针对所有的元素重复以上的步骤，除了最后一个
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

代码实例  要排序的数组：int[] arr={25,18,21,9}; 

• 排序前的数组为:25 18 21 9
• 第1趟第1次排序后数组的顺序:18 25 21 9
• 第1趟第2次排序后数组的顺序:18 21 25 9
• 第1趟第3次排序后数组的顺序:18 21 9 25
• 第1趟排序后数组的顺序:18 21 9 25
• 第2趟第1次排序后数组的顺序:18 21 9 25
• 第2趟第2次排序后数组的顺序:18 9 21 25
• 第2趟排序后数组的顺序:18 9 21 25
• 第3趟第1次排序后数组的顺序:9 18 21 25
• 第3趟排序后数组的顺序:9 18 21 25
• 排序后的数组为:9 18 21 25

冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

用时间复杂度来说：

　　1.如果我们的数据正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，即：C_min=n-1;M_min=0;所以，冒泡排序最好的时间复杂度为O_(n)。

 2.如果很不幸我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

       

       冒泡排序的最坏时间复杂度为：O_(n²) 。

综上所述：冒泡排序总的平均时间复杂度为：O_(n²) 

package com.yyx.sortingAlgorithm;
/**
 * 冒泡排序
 * yyx 2018年2月3日
 */
public class BubbleSort {
    public static void main(String[] args) {
        int temp;
        int[] arr={25,18,21,9}; 
        System.out.print("排序前的数组为:");
        for(int num:arr){
            System.out.print(num+" ");
        }
        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;
                }
                System.out.println();
                System.out.print("第"+(i+1)+"趟第"+(j+1)+"次排序后数组的顺序:");
                for(int num:arr){
                    System.out.print(num+" ");
                }
            }
            System.out.println();
            System.out.print("第"+(i+1)+"趟排序后数组的顺序:");
            for(int num:arr){
                System.out.print(num+" ");
            }
            System.out.println();
        }
        System.out.println();
        System.out.print("排序后的数组为:");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }
}

     优化

     对冒泡排序常见的改进方法是加入标志性变量exchange，用于标志某一趟排序过程中是否有数据交换。如果进行某一趟排序时并没有进行数据交换，

则说明所有数据已经有序，可立即结束排序，避免不必要的比较过程

package com.yyx.sortingAlgorithm;

/**
 * 冒泡排序:它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
 *        走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成
 * yyx 2018年2月3日
 */
public class BubbleSort {
    public static void main(String[] args) {
        int temp;
        boolean bChange = false;
        int[] arr = { 25, 18, 21, 9 };
        //循环的趟数
        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;
                    bChange = true;
                }
            }
            // bChange==false表示没有交换
            if (bChange == false) {
                break;
            }
        }
        System.out.print("排序后的数组为:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}