排序算法总结

1、冒泡排序（内部排序：交换排序）

时间复杂度：

   最好情况：O(n)，最差情况 O(n2) ，平均情况  O(n2) 

空间复杂度：O(1)

稳定性：稳定

    /**
     * 冒泡排序
     * @param array
     * @return
     */
    public static int[] bubbleSort (int[] array) {
        if (array.length == 0) {
            return array;
        }
        for (int i = 0; i < array.length - 1; i ++) {
            for (int j = 0; j < array.length - 1 - i; j ++) {
                if (array[j] > array [j+1]) {
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }

2、简单选择排序（内部排序：简单选择排序）
 

时间复杂度：

   最好情况：O(n2)，最差情况 O(n2) ，平均情况  O(n2)

空间复杂度：O(1)

稳定性：不稳定

    /**
     * 简单选择排序
     * @param array
     * @return
     */
    public static int[] selectionSort (int[] array) {
        if (array.length == 0) {
            return array;
        }
        for (int i = 0; i < array.length - 1; i ++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j ++ ) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
        return array;
    }

3、直接插入排序（内部排序：插入排序）

时间复杂度：

   最好情况：O(n)，最差情况 O(n2) ，平均情况  O(n2) 

空间复杂度：O(1)

稳定性：稳定

    /**
     * 插入排序
     * @param array
     * @return
     */
    public static int[] insertionSort (int[] array) {
        if (array.length == 0) {
            return array;
        }
        int current;
        for (int i = 0; i < array.length - 1; i ++) {
            current = array[i+1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex+1] = array[preIndex];
                preIndex--;
            }
            array[preIndex+1] = current;
        }
        return array;
    }