数据结构-排序算法总结

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);
        }
    }