排序算法（java）

简介及相关概念：使用java是实现常用的排序算法；
稳定：如果排序前a在b前面，而a=b，经过排序后a依旧还在b的前面。
不稳定：如果未经排序a在b前面，而此时依旧a=b，经过排序后a可能出现在b的后面。
时间复杂度：是指排序时随着排序的数据规模的大小与所需的时间变化规律。
空间复杂度：是指排序时排序的数据规模与所需的空间变化规律
排序算法分类：

• 非线性时间比较类排序： 通过比较来决定元素间的相对次序，由于时间复杂度不能突破logn的，所以被称为非线性时间复杂度。
• 线性时间比较类排序：不通过比较来决定元素间的相对次序，可以突破基于时间复杂度为logn的下界，以线性时间运行，因此称为线性时间比较类排序。

分类图如下

时间复杂度图：

冒泡排序（bubble sort）： 是一种简单排序算法，是通过比较两个相邻的元素大小，如果相邻的元素之间大小打不通，则进行交，把小的元素往前移动，直至排序的数据为有序的。（全套循环，每次查看相邻的元素大小，如果是逆序的，则进行交换。）
代码实现：

public void bubbleSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i <  len - 1 ; i++) {
            // 减少循环的范围，i 之后就把比较大的排到后面
            for (int j = 0; j < len - i - 1; j++) {
                // 相邻的两个元素进行比较
                if (arr[j] > arr[j + 1]) {
                    // 交换位置
                    int temp = arr[j + 1];
                    // 大的往后移动
                    arr[j + 1] = arr[j];
                    // 小的前移
                    arr[j] = temp;
                }
            }
        }
    }

选择排序(seelection sort)： 每次选择最小的元素放到待排序的数组前面。
插入排序（insertion sort）：从前到后逐步构建有序的序列，，对为排序数据，在已排序序列中从后往前扫描，，找到响应的位置并插入,
代码实现如下：

 public void selectionSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
            int minIndex = i, temp = arr[0];
            for (int j = i + 1; j < len; j++) {
                if (arr[j] < arr[i]) {
                    // 记录最小值
                    temp = arr[j];
                    minIndex = j;
                    arr[minIndex] = arr[i];
                    arr[i] = temp;
                }
            }
        }
    }

快速排序： 数组选择一个标杆privot,小的元素放在prviot左边，大的放在privot放在右边，然后对于左右子数组进行快拍，达到整个数组的有序。

 public static void quickSort(int[] arr, int low, int high) {
        int i, j, key;
        if (low > high) {
            return;
        }
        i = low;
        j = high;
        //temp就是基准位
        key = arr[low];

        while (i < j) {
            //j向左移，直到遇到比key小的值
            while(arr[j]>=key && i<j){
                j--;
            }
            //i向右移，直到遇到比key大的值
            while(arr[i]<=key && i<j){
                i++;
            }
            //如果满足条件则交换
            if (i < j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        //最后将基准为与i和j相等位置的数字交换
        arr[low] = arr[i];
        arr[i] = key;
        //递归调用左半数组
        quickSort(arr, low, i - 1);
        //递归调用右半数组
        quickSort(arr, i + 1, high);
    }

归并排序： 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
1、把长度为n的数组分为两个长度n/2的子数组。
2、对两个这个两个子序列进行归并排序，
3、将归并好的子序列合并成一个最终的结果。
实现源码如下：

 public void mergeSort(int[] arr, int left, int right) {
        if (left > right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }

    private void merge(int[] arr, int left, int mid, int right) {

        /**
         * 分割后左边的数组下标为[left, mid],右边数组下标的为[mid - 1, right]，
         * 此时左边的元素个数为 mid - left + 1, 右边的个位为 right -mid
         */
        int LAL = mid - left + 1;
        int RAL = right - mid;
        // 加一操作是增加无穷大标志位
        int[] leftArr = new int[LAL + 1];
        int[] rightArr = new int[RAL + 1];

        // 用新数组来一份为二
        for (int i = 0; i < LAL; i++)
            leftArr[i] = arr[left + i];

        for (int i = 0; i < RAL; i++)
            leftArr[i] = arr[mid + i + 1];
        int i = 0, j = 0;
        //将最大的正整数放在两个新数组的最后一位
        leftArr[LAL] = Integer.MAX_VALUE;
        rightArr[RAL] = Integer.MAX_VALUE;
        // 数据小的往前移动。
        for (int k = left; k < right; k++) {
            if (leftArr[i] <= rightArr[j]) {
                arr[k] = leftArr[i];
                ++i;
            } else {
                arr[k] = rightArr[j];
                ++j;
            }
        }
    }

推排序（heap sort ）： 一推插入（logn）,取值O(1)
数据依次加入，到堆上，取出最大/最小元素并删除
代码实现如下：

 public void heapSort(int[] arr) {
        int length = arr.length;
        // 开始创建傻逼的推（大推）
        for (int i = (length - 1) / 2; i < length; i++) {
            // 从第一个非叶子节点从下至上的，从右到左调整。
            helper(arr, i, length);
        }
        // 调整堆结构 + 交换堆顶元素与末尾元素交换。
        for (int i = length - 1; i > 0; i--) {
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            helper(arr, 0, length);
        }
    }

    private void helper(int[] arr, int index, int max) {
        int left = index * 2 + 1;
        int right = index * 2 + 2;
        int larges = 0;
        if (left < max && arr[left] > arr[index]) {
            larges = left;
        } else {
            larges = index;
        }
        if (right < max && arr[right] > arr[larges]) {
            larges = right;
        }
        if (larges != index) {
            int temp = arr[larges];
            arr[larges] = arr[index];
            arr[index] = temp;
            // 递归直至调整符合最大推
            helper(arr, larges, max);
        }
    }