各大排序算法的分析与实现以及时间复杂度

时间复杂度：

时间复杂度是一个算法流程中，常数操作数量的指标。常用O表示。在常数操作数量的表达式中，只要高阶项，不要低阶项，也不要高阶项系数，剩下的部分如果记为f(n)，那么时间复杂度就是O(f(n))。

一、冒泡排序

思想：n个数一一对比之后找出最大的，再在剩下的n-1个数中一一对比找出第二大的，以此类推。

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

实现代码：

    public static void bubbleSort(int[] arr) {
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                //如果前一个数比后一个数大就交换
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

二、选择排序

思想：n个数中第一个数与后面的数字比较，若有更小的就交换，从而让第一个数字为最小值，接着再处理剩下的n-1个数，以此类推。

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

实现代码：

    public static void insertionSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                //如果有小于min的值，就改变min的下标
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            swap(arr, i, minIndex);
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

三、插入排序

思想：第二个数先与第一个数比较，形成有序序列。接着第三个数和前两个形成有序序列的数字比较，找到合适的位置插入。以此类推。

最好的时间复杂度：O(n)

最坏的时间复杂度：O(n^2)

实现代码：

    public static void insertionSort(int arr[]) {
        //从第二个数开始插入
        for (int i = 1; i < arr.length; i++) {
            //该数与前面形成的有序序列进行比较，该数较小的话就交换，直到插入合适位置，较大的话就不交换
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

四、归并排序

思想：采用分治的思想，将n个元素的数组切成一半，每一半再分别排序，最后将两半已经排序的数组合并。

时间复杂度：O(n*logn)

空间复杂度：O(n)

实现代码：

    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) return;
        mergeSort(arr, 0, arr.length - 1);
    }

    public static void mergeSort(int[] arr, int index, int end) {
        if (index == end) return;
        int mid = index + (end - index) / 2;
        mergeSort(arr, index, mid);
        mergeSort(arr, mid + 1, end);
        //合并两个数组
        merge(arr, index, mid, end);
    }

    public static void merge(int[] arr, int index, int mid, int end) {
        //构造辅助数组
        int[] help = new int[end - index + 1];
        int i = 0;
        int p1 = index;
        int p2 = mid + 1;
        //哪个比较小就放入辅助数组，并且移动指针
        while (p1 <= mid && p2 <= end) {
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        //说明p2指针移动完毕，只剩p1
        while (p1 <= mid) {
            help[i++] = arr[p1++];
        }
        //说明p1指针移动完毕，只剩p2
        while (p2 <= end) {
            help[i++] = arr[p2++];
        }
        //将辅助数组的元素复制回原来数组
        for (int j = 0; j < help.length; j++) {
            arr[index + j] = help[j];
        }
    }

五、快速排序（改进后的）

思想：把数组中的最后一个元素作为分界量，也就是基准点，排成左边比它小的，中间等于它的，右边比它大的。再递归调用分别排左边的和右边的。

最好的时间复杂度：O(n*logn)

最坏的时间复杂度：O(n^2)

长期期望的时间复杂度：O(n*logn)

长期期望的额外空间复杂度：O(logn)

实现代码：

    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) return;
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int index, int end) {
        if (index < end) {
            //swap(arr, l + (int) (Math.random() * (r - l + 1)), r);（这一句加上就是随机快速排序，暂时不加）
            //p数组代表的是等于划分基准点的元素的初始和结束位置
            int[] p = partition(arr, index, end);
            quickSort(arr, index, p[0] - 1);
            quickSort(arr, p[1] + 1, end);
        }
    }

    //下面是以数组的最后一个元素作为基准点的，这个方法完成的结果就是小于基准点放左边，等于基准点放中间，大于基准点放右边
    public static int[] partition(int[] arr, int index, int end) {
        //less指针用来划分小于基准点的范围
        int less = index - 1;
        //more指针用来划分大于基准点的范围
        int more = end;
        while (index < more) {
            //如果当前元素小于基准点的元素，就让它与less指针的前一个数字交换，并移动less指针，移动index指针操作下一个数
            //如果当前元素大于基准点的元素，就让它与more指针的前一个数字交换，并移动more指针
            //如果当前元素等于基准点的元素，移动index指针操作下一个数
            if (arr[index] < arr[end]) {
                swap(arr, index++, ++less);
            } else if (arr[index] > arr[end]) {
                swap(arr, index, --more);
            } else {
                index++;
            }
        }
        //由于基准点的元素一直没有动过，最后要让它和大于基准点的元素交换
        swap(arr, more, end);
        //返回等于基准点元素的下标
        return new int[]{less + 1, more};
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

六、堆排序

思想：先让数组的n个元素依次进堆，构建出大顶堆。然后交换顶堆的元素和最末尾的元素（最末尾的元素不一定最小，但是一定小于等于堆顶的元素），然后让剩下的n-1元素进行调整，重新调整为大顶堆。然后在进行交换，再调整，以此类推。

时间复杂度：O(n*logn)

实现代码：

    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) return;
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);
        }
        int size = arr.length;
        swap(arr, 0, --size);
        while (size > 0) {
            heapify(arr, 0, size);
            swap(arr, 0, --size);
        }
    }

    //建立大顶堆的过程
    public static void heapInsert(int[] arr, int index) {
        //如果当前值大于父节点的话，与父节点交换
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    //重新调整成为大顶堆的过程
    public static void heapify(int[] arr, int index, int size) {
        //取该结点的左结点
        int left = index * 2 + 1;
        //如果左结点在size范围内
        while (left < size) {
            //从左右结点中选出最大的，赋给largest
            int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
            //判断当前结点和左右结点的最大值比较，如果当前结点大就维持原样（因为调整到index的结点可能比左结点的值要大的）
            if (arr[largest]<arr[index]) {
                break;
            }
            //交换index和largest结点的值
            swap(arr, largest, index);
            //让index指针移动到largest结点位置
            index = largest;
            //取index的左结点
            left = index * 2 + 1;
        }

    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

排序算法的稳定性

排完顺序之后不会改变相同的原数字在原来数组中的相对次序，称为稳定。反之为不稳定

冒泡排序：稳定

选择排序：不稳定

插入排序：稳定

归并排序：稳定

快速排序：不稳定

堆排序：不稳定