冒泡排序

冒泡排序的时间复杂度为O(n^2)。算法思想是通过相邻元素的比较交换，将最小元素上浮到最上层。

public class BubbleSort {
    public static void main(String[] args) {
        //冒泡排序，从小到大
        BubbleSort bubbleSort = new BubbleSort();
        int[] array = {2, 1, 5, 8, 3, 6};
        bubbleSort.sortV1(array);
        bubbleSort.print(array);
        array = new int[]{2, 1, 5, 8, 3, 6};
        bubbleSort.sortV2(array);
        bubbleSort.print(array);
        array = new int[]{2, 1, 5, 8, 3, 6};
        bubbleSort.sortV3(array);
        bubbleSort.print(array);
        array = new int[]{2, 1, 5, 8, 3, 6};
        bubbleSort.sortV4(array);
        bubbleSort.print(array);
    }

    //数组元素交换
    private void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }

    //数组打印
    private void print(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }


    //冒泡排序，时间复杂度为O(n^2)
    public void sortV1(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = array.length - 1; j > 0; j--) {
                //从后往前，每次循环都将最小元素移动到最前位置
                if (array[j] < array[j - 1]) {
                    swap(array, j, j - 1);
                }
            }
        }
    }

    //冒泡排序优化，减少循环次数
    public void sortV2(int[] array) {
        //最外层最多比较array.length - 1次
        for (int i = 0; i < array.length - 1; i++) {
            //本次循环是否有序,如果执行到某次循环发现是有序的，则不用继续后续的循环操作。
            boolean isSorted = true;
            //内层比较array.length - 1 - i次
            for (int j = array.length - 1; j > i; j--) {
                //从后往前，每次循环都将最小元素移动到最前位置
                if (array[j] < array[j - 1]) {
                    swap(array, j, j - 1);
                    isSorted = false;
                }
            }

            if (isSorted) {
                break;
            }
        }
    }

    //冒泡排序升级，当序列部分有序时能提升效率
    public void sortV3(int[] array) {
        //最后一次交换的索引位置
        int lastExchangeIndex = 0;
        //序列有序和无序的边界
        int sortBorder = 0;
        for (int i = 0; i < array.length - 1; i++) {
            boolean isSorted = true;
            for (int j = array.length - 1; j > sortBorder; j--) {
                if (array[j] < array[j - 1]) {
                    swap(array, j, j - 1);
                    isSorted = false;

                    lastExchangeIndex = j;
                }
            }
            //记录本次循环最后一次交换的下标，作为下次循环的边界位置
            sortBorder = lastExchangeIndex;
            if (isSorted) {
                break;
            }
        }
    }

    //冒泡排序升级-鸡尾酒排序
    //排序过程向钟摆一样，从左到右排序，然后从右到左排序，如此反复
    public void sortV4(int[] array) {
        //循环一次会对两个元素排序，如最小在最左边，最大在最右边
        for (int i = 0; i < array.length / 2; i++) {
            //从左到右排序
            boolean isSorted = true;
            for (int j = i; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    isSorted = false;
                }
            }

            if (isSorted) {
                break;
            }

            //从右到左排序
            isSorted = true;
            for (int j = array.length - i - 1; j > i; j--) {
                if (array[j] < array[j - 1]) {
                    swap(array, j, j - 1);
                    isSorted = false;
                }
            }

            if (isSorted) {
                break;
            }
        }
    }
}