几种排序算法总结

（一）时间复杂度为O(n²)的算法

1.冒泡排序

       两两比较选择，每一次比较将大的往后移。

       空间复杂度O（1）,稳定的排序。

public static void bubbleSort(int[] nums) {
        for (int i = nums.length - 1; i >= 0; --i) {
            for (int j = 0; j <= i - 1; ++j) {
                if (nums[j] >= nums[j + 1]) swap(nums, j, j + 1);
            }
        }
    }

2.选择排序

       每次选出最大值放在数组末尾。

       空间复杂度O(1)，不稳定的排序。

    public static void selectSort(int[] nums) {
        for (int i = 0; i < nums.length; ++i) {
            for (int j = i; j <nums.length; j++) {
                if (nums[j] < nums[i]) swap(nums,i,j);
            }
        }
    }

3.插入排序

       将数组中未排序的新的一个数插入到已排序好的数组中 ，在最坏情况（倒序）下时间复杂度为O（n²），在数组已经比较有序时有较好的表现。空间复杂度O(1)，稳定的排序。

    public static void insertSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (nums[j + 1] < nums[j]) swap(nums, j + 1, j);
                else break;
            }
        }
    }

（二）时间复杂度为O(NlogN)的算法

1.归并排序

       将左右两边排序好的数组归并到一个数组。运用递归的思想，自下而上，最终将整个数组排序。需要构建辅助数组，空间复杂度O（N）。是一种稳定的排序。

    public static void mergeSort(int[] nums, int left, int right) {
        if (left == right) return;
        int mid = left + ((right - left) >> 1);
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);
        nums = merge(nums, left, mid, right);
    }

    public static int[] merge(int[] nums, int left, int mid, int right) {
        int[] help = new int[right - left + 1];
        int p1 = left, p2 = mid + 1;
        int i = 0;
        while (p1 <= mid && p2 <= right) {
            help[i++] = nums[p1] <= nums[p2] ? nums[p1++] : nums[p2++];
        }
        while (p1 <= mid) {
            help[i++] = nums[p1++];
        }
        while (p2 <= right) {
            help[i++] = nums[p2++];
        }
        for(i=0;i<help.length;++i){
            nums[left+i]=help[i];
        }
        return nums;
    }

2.快速排序 

       以数组中随机某一个值作划分。空间复杂度O（logN）,是一种不稳定的算法。

    public static void quickSort(int[] nums, int left, int right) {
        if (left < right) {
            //随机取一个数作为划分值
            swap(nums, left+(int) (Math.random() * (right-left+1)), right);
            int[] res = partition(nums, left, right);
            quickSort(nums, left, res[0]-1);
            quickSort(nums, res[1] + 1, right);
        }
    }

    public static int[] partition(int[] arr, int left, int right) {
        //low为小于区右边界，p2为大于区左边界，index指针
        int low = left - 1, high = right;
        int index = left;
        while (index < high) {
            if (arr[index] < arr[right]) {
                swap(arr, index++, ++low);
            } else if (arr[index] > arr[right]) {
                swap(arr, index, --high);
            } else {
                index++;
            }
        }
        swap(arr, right, high);
        return new int[]{low + 1, high};
    }

3.堆排序

    借用完全二叉树建立堆，升序建立大根堆，降序建立小根堆。

    空间复杂度为O(1)，不需要建立额外空间，在数组内部交换即可完成，但是不稳定。

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

    public static void heapInsert(int[] nums, int index) {
        while (nums[index] > nums[(index - 1) / 2]) {
            swap(nums, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }

    }

    public static void heapify(int[] arr, int index, int heapSize) {
        int left = 2 * index + 1;
        while (left < heapSize) {
            //如果有右孩子，定义一个指针指向其中较大的孩子
            int largest = left + 1 < heapSize && arr[left] < arr[left + 1] ? left + 1 : left;
            //将当前数与孩子中较大的进行比较
            largest = arr[index] > arr[largest] ? index : largest;
            //相等说明当前数大于孩子，已经是大根堆了，结束循环
            if (largest == index) break;
            swap(arr, largest, index);
            index = largest;
            left = 2 * index + 1;
        }
    }