冒泡排序

代码实现（从小到大排序）

public class BubbleSort {//从小到大排序
    
    public static void bubbleSort(int[] array) {
        if (array == null || array.length <= 1) {
            return;
        }
        int temp = 0;
        int len = array.length;
        // len 个元素，要冒泡 len - 1 次
        for (int i = 1; i < len; i++) {
            for (int j = 0; j < len - i; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

 

 设置标志位：优化外循环，设置一个标志位，表示当前第 i 趟是否有交换，如果有，则要进行 i+1 趟，如果没有，则说明当前数组已经完成排序

public class BubbleSort {//从小到大排序
    
    public static void bubbleSort(int[] array) {
        if (array == null || array.length <= 1) {
            return;
        }
        int temp = 0;
        int len = array.length;
        int isSorted = false;
        // len 个元素，要冒泡 len - 1 次
        for (int i = 1; i < len; i++) {
            isSorted = false;
            for (int j = 0; j < len - i; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    isSorted = true;
                }
            }
            if (!isSorted) {
                break;
            }
        }
    }
}

 

鸡尾酒排序：优化内循环，适合用在大多数元素已经是有序的前提下，可以减少每一次遍历的比较次数

public class BubbleSort {//从小到大排序
    
    public static void bubbleSort(int[] array) {
        if (array == null || array.length <= 1) {
            return;
        }
        
        int temp = 0;
        int rightBorder = array.length - 1;//数组右边界
        int leftBorder = 0;//数组左边界
        int end = 0;
        boolean isSorted = false;
        
        for (int i = 0; i < array.length / 2; i++) {//向左或向右遍历的次数最多为array.length/2次
            isSorted = false;
            for (int j = leftBorder; j < rightBorder; j++) {//从左往右遍历比较
                if (array[j] > array[j + 1]) {//从小到大排序
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    end = j;//记录向右遍历时最后一次交换时的索引
                    isSorted = true;
                }
            }
            rightBorder = end;//向右遍历时最后一次交换时的索引作为新的右边界
            if (!isSorted) {//isSorted == false，说明内层for循环中，没有交换任何元素，直接跳出外层循环
                break;
            }
            
            for (int j = rightBorder; j > leftBorder; j--) {//从右往左遍历比较
                if (array[j] < array[j - 1]) {//从小到大排序
                    temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                    end = j;//记录向左遍历时最后一次交换时的索引
                    isSorted = true;
                }
            }
            leftBorder = end;//向左遍历时最后一次交换时的索引作为新的左边界
            if (!isSorted) {//isSorted == false，说明内层for循环中，没有交换任何元素，直接跳出外层循环
                break;
            }
            
            if (leftBorder >= rightBorder) {//左边界大于等于右边界时，排序结束
                break;
            }
        }
    }
}