常考的排序算法-冒泡排序和快速排序(Java版)

冒泡排序(n^2)

思想:排n次,每次把没排好的最大的挑出来,然后排到后面去,最大的排最后面,次大的排倒数第二个..
加一个flag优化一下

class Solution {
    private static void bubbleSort(int[] array) {
        int n = array.length;
        int flag = 1; //用于判断如果没有交换的,就提前中断
        for (int i = 0; i < n && flag == 1; i++) {
            flag = 0;
            for (int j = 0; j < n - i - 1; j++) { //每次把最大的放在最后面
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                    flag = 1;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {5,4,3,1,2,-1};
        bubbleSort(a);
        for (int i : a) {
            System.out.print(i + " ");
        }
    }
}

 排序过程:每次把最大的放到后面

 

2.快速排序(nlogn)

每次挑一个标志值,在一遍排序后,前面的值都比标志值小,后面的都比标志值大.
时间复杂度nlogn
 

class Solution {
    private static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int index = getIndex(array, low, high);
            quickSort(array, low, index - 1);//递归求解
            quickSort(array, index + 1, high);
        }
    }

    private static int getIndex(int[] array, int low, int high) {
        int temp = array[low]; //把第一个数当做标志值
        while (low < high) {
            while (low < high && array[high] >= temp) {//找到第一个比temp小的值
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= temp) {//找到第一个比temp大的值
                low++;
            }
            array[high] = array[low];
        }
        array[low] = temp;//最后把找到的中间的地方赋值
        return low;
    }

    public static void main(String[] args) {
        int[] a = {3, 5, 1, 2, -1, 4};
        quickSort(a, 0, a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

 排序过程,这个例子和冒泡排序的例子不一样,每一次都是把标志值的左右两侧先排好