数据结构-排序算法总结

1、二路归并排序

/*

     * 二路归并排序

     * 思路：利用分治思想，对原数组进行二分分段，使元素在每一小段内有序，然后逐渐合并

     * 如，最小分段是2，先2内有序，合并为4,4内有序。。。。

     *

     * 时间复杂度：O(nlogn)

     * 空间复杂度：O(n)需要一个额外的数组作为临时存储

     */

    static void mergeSort(int array[], int helper[], int left, int right) {

        if (left >= right)

            return;

        int mid = (left + right) / 2;

        mergeSort(array, helper, left, mid);

        mergeSort(array, helper, mid + 1, right);

        int helperLeft = left;

        int helperRight = mid + 1;

        int cur = left;

        for (int i = left; i <= right; i++) {

            helper[i] = array[i];

        }

        while (helperLeft <= mid && helperRight <= right) {

            if (helper[helperLeft] <= helper[helperRight])

                array[cur++] = helper[helperLeft++];

            else

                array[cur++] = helper[helperRight++];

        }

        while (helperLeft <= mid)

            array[cur++] = helper[helperLeft++];

    }

2、快速排序

/*

     * 快速排序

     * 思路：先选择一个哨兵元素，然后后往前遍历，遇到比哨兵小的元素停止，从前往后进行遍历，

     * 遇到比哨兵元素大的元素停止，交换两个元素，继续，直到前后相遇，此时交换相遇点的元素

     * 和哨兵元素，一趟排序下来，可以确保哨兵元素左边的元素比哨兵小，右边的元素比哨兵大（升序排序）；

     * 然后分区间再继续上述过程

     * 注意：通常选取左边界作为哨兵元素，此时，必定先进行从后往前的移动，否则不对称缺项会出错

     *

     * 时间复杂度：平均O(nlogn) 最差O(n^2)

     * 空间复杂度：O(logn)交换时需要一个额外的空间，一共交换logn次

     */

    static void quickSort(int array[], int left, int right) {

        if (left >= right)

            return;

        int pivot = array[left];

        int i = left;

        int j = right;

        while (i != j) {

            while (array[j] >= pivot && j > i)

                j--;

            while (array[i] <= pivot && i < j)

                i++;

            if (i < j) {

                int temp = array[i];

                array[i] = array[j];

                array[j] = temp;

            }

        }

        array[left] = array[i];

        array[i] = pivot;

        quickSort(array, left, i - 1);

        quickSort(array, i + 1, right);

    }

3、堆排序

/*

     * 堆排序

     */

    //调整堆，larger=true大顶堆，否则为小顶堆

    static void adjustHeap(int array[], int parent, int length, bool large) {

        int pivot = array[parent]; //保存当前父节点

        int child = 2 * parent + 1; //获取左孩子

        while (child < length) {

            if (large) {

                //大顶堆

                //如果有右孩子，且右孩子大于左孩子，选取有孩子节点

                if (child + 1 < length && array[child] < array[child + 1])

                    child++;

                // 如果父节点的值已经大于孩子节点的值，则直接结束

                if (array[parent] >= array[child])

                    break;

            } else {

                //如果有右孩子，且右孩子小于左孩子，选取右孩子节点

                if (child + 1 < length && array[child] > array[child + 1])

                    child++;

                //如果父节点的值已经小于孩子节点的值，则直接结束

                if (array[parent] < array[child])

                    break;

            }

            //把孩子节点的值赋给父节点

            array[parent] = array[child];

            //选取孩子节点的左孩子节点，继续向下筛选

            parent = child;

            child = child * 2 + 1;

　　　　　　　array[parent] = pivot;　

        }

    }

    /*

     * 初始化堆

     * 调整之后，第一个元素为序列的极值

     */

    static void buildHeap(int array[], int length, bool large) {

        for (int i = (length - 1) / 2; i >= 0; --i)

            adjustHeap(array, i, length, large);

    }

    /*

     * 初次建堆时间复杂度O(n)

     * 调整一次的时间为O(logn),一共调整n次

     * 时间复杂度为O(nlogn)

     * 空间复杂度O(1)

     */

    static void heapSort(int array[], int length, bool increase) {

        bool large;

        if (increase) {

            large = true;

        } else {

            large = false;

        }

        buildHeap(array, length, large);

        print(array, length);

        //将极值逐渐放到队尾，剩下元素重新调整

        for (int i = length - 1; i > 0; i--) {

            int temp = array[i];

            array[i] = array[0];

            array[0] = temp;

            adjustHeap(array, 0, i, large);

            print(array, length);

        }

    }

4、直接插入排序

/*

     * 直接插入排序

     * 思路：由第二个元素开始，从前向后遍历，如若当前元素比前一个元素小，则将

     * 当前元素设为哨兵元素，保存当前元素，从当前位置向前扫描，寻找哨兵元素应该插入的位置，

     * 前面的元素依次后移，找到直接插入。然后继续上述过程

     * 时间复杂度：O(n^2)

     * 空间复杂度：O(1)

     */

    static void directInsertSort(int array[], int length) {

        //升序版本

        for (int i = 1; i < length; i++) {

            if (array[i] < array[i - 1]) {                //找到小数

                int j = i - 1;

                int pivot = array[i];                //复制小数为哨兵元素

                array[i] = array[i - 1];                //先进行一次后移

                while (pivot < array[j] && j >= 0) {                //寻找小数插入位置

                    array[j + 1] = array[j];

                    j--;

                }

                array[j + 1] = pivot;

            }

        }

    }

5、希尔排序

/*

     * shell排序（缩小增量排序）

     * 思路：以一定间隔对数组进行分组，在组上进行直接插入排序，使之有序，之后缩小间隔，

     * 重复上述过程

     * 时间复杂度：O(n^1.5)

     * 空间复杂度：O(1)

     */

    static void shellSort(int array[], int length) {

        int gap = length / 2;

        while (gap >= 1) {

            //距离间隔gap为一组，遍历所有组

            for (int i = gap; i < length; i++) {

                if (array[i] < array[i - gap]) {

                    int j = i - gap;

                    int x = array[i];

                    array[i] = array[j];

                    //寻找x在当前序列上的插入点

                    while (x < array[j] && j >= 0) {

                        array[j + gap] = array[j];

                        j -= gap;

                    }

                    array[j + gap] = x;

                }

            }

            print(array, length);

            gap /= 2;

        }

    }

6、冒泡排序

    /*

     * 冒泡排序

     * 思路：每次内循环使相邻元素有序，单次循环后最大值沉底（升序时）

     * 之后缩短内循环范围，继续上述操作，但是 有个问题，太冗杂

     * 时间复杂度：O(N^2)

     * 空间复杂度：O(1)

     */

    static void bubbleSort(int array[], int length) {

        for (int i = 0; i < length - 1; i++) {

            for (int j = 0; j < length - i - 1; j++) {

                if (array[j] > array[j + 1]) {

                    int temp = array[j];

                    array[j] = array[j + 1];

                    array[j + 1] = temp;

                }

            }

            print(array, length);

        }

    }