Java中插入排序和选择排序算法

排序之前我们从时间复杂度，空间复杂度和稳定性三方面分析算法。

 

七大基于比较的排序

 

1、插入排序

1.1直接插入排序

/**
     * 时间复杂度：
     *      最坏情况：O(n^2)         最好情况(有序的情况)： O(n)
     *      越有序越快
     * 空间复杂度： O(1)
     * 稳定性： 稳定
     * @param array
     */
    public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if (array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }

1.2希尔排序

/**
     * 时间复杂度：
     *      最好情况： O(n)      最坏情况：O(n^2)
     * 空间复杂度： O(1)
     * 稳定性： 不稳定
     * @param array
     * @param gap
     */
    public static void shell(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i - gap;
            for (; j >= 0; j -= gap) {
                if (array[j] > tmp) {
                    array[j + gap] = array[j];
                }else {
                    break;
                }
            }
            array[j + gap] = tmp;
        }
    }

    public static void shellSort(int[] array) {
        int[] drr= {5,3,1};
        for (int i = 0; i < drr.length; i++) {
            shell(array,drr[i]);
        }
    }

2、选择排序

2.1选择排序

/**
     * 时间复杂度 ： O(n^2)
     * 空间复杂度 ：O(1)
     * 稳定性：不稳定 排序
     * @param array
     */
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    int tmp = array[j];
                    array[j] = array[i];
                    array[i] = tmp;
                }
            }
        }
    }

2.2堆排序

 /**
     * 时间复杂度： O(nlogn) 不管有序还是无序都是
     * 空间复杂度： O(1)
     * 稳定性： 不稳定
     * @param array
     */
    public static void heapSort(int[] array) {
        createHeap(array);
        int end = array.length - 1;
        while (end > 0) {
            int tmp = array[0];
            array[0] = array[end];
            array[end] = tmp;
            adjustDown(array,0,end);
            end--;
        }
    }

    public static void createHeap(int[] array) {
        for (int i = (array.length-1-1)/2; i >= 0; i--) {
            adjustDown(array,i,array.length);
        }
    }

    public static void adjustDown(int[] array, int root, int len) {
        int parent = root;
        int child = 2*parent + 1;
        while (child < len) {
            if(child+1 < len && array[child] < array[child+1]) {
                child++;
            }
            if (array[child] > array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

交换排序、归并排序：https://blog.csdn.net/m0_46611181/article/details/106338253