排序算法-冒泡排序

package com.test.sort;

import java.util.Arrays;

/**
 *  冒泡排序基本思想：
 *    通过对待排序序列从前向后，依次比较相邻的值，若发现逆序则交换，使值较大的元素
 *    逐渐从前移向后部。就像水下 的气泡一样逐渐向上冒
 */
public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] arr=new int[]{0,1,2,3};
        sortOfBubble(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     *  将数组从大到小排列
     *  分析：{0,2,1,5,3}
     *   第一轮比较，从下标0开始，相邻元素比较，如果逆序则交换位置，最后得到最小的数放至arr.length-1
     *             比较arr.length-1次
     *   第二轮比较，从下标0开始，相邻元素比较，如果逆序则交换位置，直到倒数第二位。因为上一轮已经
     *            和倒数第一位比较过，无需再次比较，因此直接放至arr.length-2，比较arr.length-2
     *   第三轮比较 ，……
     *   第n轮比较，将最值放至arr.length-n,比较arr.length-n次
     *   最后一轮比较，arr[0]与arr[arr.length-n]即arr[2]比较，排序完成
     *   因为每轮都需要从下标0开始，假定arr[0]最小，则需要比较arr.length-1轮
     *   总结：1、共比较arr.length-1轮
     *        2、每轮比较(arr.length-当前轮数)次
     *        执行次数公式：f(n)=(n-1)n/2=(n²-n)/2
     *        时间复杂度:O(n²)
     *
     *   i为轮数，j为每轮比较的次数
     * @param arr 1
     */
    public static void sortOfBubble(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];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

    /**
     * 对上面的冒泡排序优化
     * 增加标识项flag,当发生了交换flag=true 当某轮比较中一次交换都没发生，说明序列已经有序，无需继续比较
     * 如果发生交换，flag重置，继续下轮判断
     * @param arr
     */
    public static void optimalSortOfBubble(int[] arr){
        boolean flag=false;
        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]){
                    flag=true;
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            if(!flag){
                break;
            }else {
                flag=false;
            }
        }
    }
}