一个快速排序，一个堆排序，一个归并排序，全部被张三防出去了啊
在经典的八大排序算法中，由于快速排序、堆排序和归并排序的时间复杂度可以达到O(nlogn)，且复杂性较高，所以是面试中比较常问的点，今天我们一起来复习一下这三种排序算法。
说明：本文中所有的排序都是按升序进行排序
归并排序
基本思路：借助额外空间，将两个较短数组合并为一个更长的有序数组，整个过程递归执行，直到得到数组的长度等于原数组长度
算法思想：分治思想
算法过程：
首先对数组进行等长划分，整个过程递归执行，直到子数组长度全部为1
对两个子数组进行归并，由于子数组自身有序，因此两个子数组指针从头开始往后移动，将两个子数组指针指向值的更小值放入排序数组，同时该指针向后移动，直到两个指针都达到数组尾部，将得到的排序数组作为返回值返回，作为上一层递归的子数组。
递归执行第二步，直到整个数组有序
归并排序的思想还是比较直观的，归并排序本身还分为自顶向下和自底向上，我们刚刚说的这种是自顶向下的思想。而自底向上的思路也是比较直观的，会在后面给出的代码中给出详细的注释，这里就不再赘述啦，思想上都是差不多的
public class Solution {
// 自顶向下的归并排序
public int[] sortArray(int[] nums) {
int len = nums.length;
//temp是辅助数组，用于存放两个子数组中的值
int[] temp = new int[len];
mergeSort(nums, 0, len - 1, temp);
return nums;
}
private void mergeSort(int[] nums, int left, int right, int[] temp) {
//此时子数组长度为一，划分子数组过程结束，
//返回进入后续归并过程
if(right==left)
return ;
//将原数组划分为两个等长子数组
int mid = left + (right - left) / 2;
//对左侧进行归并排序
mergeSort(nums, left, mid, temp);
//对右侧进行归并排序
mergeSort(nums, mid + 1, right, temp);
// 左侧区间最后一个元素下标为mid
// 右侧区间第一个元素下标为mid+1
// 左右数组都有序
// 因此nums[mid] <= nums[mid + 1]
// 说明left到right区间内完全有序
// 直接返回无需再次排序
if (nums[mid] <= nums[mid + 1]) {
return;
}
//对两个子数组进行排序
mergeOfTwoSortedArray(nums, left, mid, right, temp);
}
private void mergeOfTwoSortedArray(int[] nums, int left, int mid, int right, int[] temp) {
//将元素拷贝到temp中，
System.arraycopy(nums, left, temp, left, right + 1 - left);
// i为左侧区间指针
int i = left;
// j为右侧区间指针
int j = mid + 1;
for (int k = left; k <= right; k++) {
if (i == mid + 1) {
//左侧区间到头了
// 直接取右侧区间元素
nums[k] = temp[j];
j++;
} else if (j == right + 1) {
// 右侧区间到头了
// 直接去左侧区间元素
nums[k] = temp[i];
i++;
} else if (temp[i] <= temp[j]) {
// 注意写成 < 就丢失了稳定性（相同元素原来靠前的排序以后依然靠前）
nums[k] = temp[i];
i++;
} else {
// 这部分的条件等价于temp[i] > temp[j]
nums[k] = temp[j];
j++;
}
}
}
}
时间复杂度O(nlogn)
空间复杂度O(n)
稳定的排序算法
自底向上的归并排序代码
class Solution {
//自底向上的归并排序
public int[] sortArray(int[] nums) {
//temp为辅助数组
int[] temp = new int[nums.length];
mergeSort(nums,0,nums.length-1,temp);
return nums;
}
//进行自底向上的子数组划分
public void mergeSort(int[] nums,int left ,int right , int[] temp){
int length = nums.length;
// i为当前一步的子数组长度
// 初始为1,每次翻倍
for( int i = 1 ; i < length ;i = i*2 ){
// j为划分子数组的左指针，
// 每次对两个数组进行归并
// 每次自增2*i
for( int j = 0 ; j< length - i ; j = j + i + i ){
//对子数组进行归并
//j为当前子数组左侧下标
//j+i-1是中间指针
//为了确保右指针不越界
//Math.min(length-1, j+i+i-1)表示右指针
merge(nums,j,j+i-1 , Math.min(length-1, j+i+i-1) , temp);
}
}
}
/**
*
* @param nums 排序后的数组
* @param left 最左侧下标
* @param mid 中间指针
* @param right最右侧下标
* @param temp 辅助数组
*/
public void merge(int[] nums ,int left ,int mid ,int right , int[] temp){
for( int i = left ; i <=right ; i ++){
temp[i] = nums[i];
}
int i = left;
int j = mid+1;
for( int k = left ; k<=right ; k ++){
if( i == mid+1){
nums[k] = temp[j++];
}else if(j==right+1)
nums[k] = temp[i++];
else if ( temp[i]<= temp[j] )
nums[k] = temp[i++];
else
nums[k] = temp[j++];
}
}
}
时间复杂度O(nlogn)
空间复杂度O(n)
快速排序
基本思路：找到数组中的一个值，然后确定数组中比该值更小的值有多少个，然后把比该值更小的值放在该值左侧，比该值更大的值放在右侧，然后对左右两侧重复进行上述过程
算法思想：分治思想，对已确定位置的元素左右侧进行分治
class Solution {
//快速排序算法
public int[] sortArray(int[] nums) {
quickSort(nums,0,nums.length-1);
return nums;
}
public void quickSort(int[] nums ,int left ,int right ){
//确保当前子数组长度至少为2
if( left < right){
//进行一步随机划分
int i = randomizedPartition(nums,left,right);
//对左侧进行快排
quickSort(nums , left , i-1);
//对右侧进行快排
quickSort( nums , i +1 ,right);
}
}
public int randomizedPartition(int[] nums, int left ,int right){
//通过随机函数找到一个随机下标对子数组进行划分
int i = new Random().nextInt(right - left + 1 ) + left;
//将这个随机下标放到最右侧
swap(nums ,right,i );
return partition(nums,left,right);
}
public int partition(int[] nums ,int left ,int right){
//将最右侧的值设为pivot
int pivot = nums[right];
int i = left-1;
for( int j = left ; j <right ; j ++){
//比pivot小的值则靠左进行放置
if(nums[j] <= pivot){
i++;
swap(nums,i,j);
}
}
//把pivot放到正确的下标i+1上
swap(nums,i+1,right);
//返回pivot正确下标
return i+1;
}
public void swap(int[] nums ,int i ,int j ){
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
平均时间复杂度O(nlogn) ，最差时间复杂度O(n*n)，最差时间复杂的情况会出现在数组原本就是降序排序，我们需要得到一个升序数组的时候，我们每次都要把最右侧的值放回靠左的位置，一共会进行n趟，每次遍历n个元素。为了减少这种情况的发生，我们加入了一个随机函数，可以尽量避免这种最差情况的发生。
空间复杂度O(nlogn)
堆排序
这里简单介绍一下堆排序的思想，首先将数组模拟成一个二叉堆，我们第一次遍历的时候从堆底开始，将更大的元素逐层向上交换，最后将最大元素放在堆顶，然后我们把对顶元素与最下一层最右侧的元素进行交换，并将最大元素从堆中删除。然后由于第一次遍历的时候，相对较大的元素都在相对靠上的位置，我们将堆顶元素向下沉，结束之后，把堆顶元素与最后一个元素进行交换，并把最大元素删除，重复以上过程直到堆为空即排序结束
public class Solution {
public int[] sortArray(int[] nums) {
int len = nums.length;
// 将数组整理成堆
heapify(nums);
// 循环不变量：区间 [0, i] 堆有序
for (int i = len - 1; i >= 1; ) {
// 把堆顶元素（当前最大）交换到数组末尾
swap(nums, 0, i);
// 逐步减少堆有序的部分
i--;
// 下标 0 位置下沉操作，使得区间 [0, i] 堆有序
siftDown(nums, 0, i);
}
return nums;
}
//将数组整理成堆（堆有序）
private void heapify(int[] nums) {
int len = nums.length;
// 只需要从 i = (len - 1) / 2 这个位置开始逐层下移
for (int i = (len - 1) / 2; i >= 0; i--) {
siftDown(nums, i, len - 1);
}
}
/**
* @param nums
* @param k 当前下沉元素的下标
* @param end [0, end] 是 nums 的有效部分
*/
private void siftDown(int[] nums, int k, int end) {
while (2 * k + 1 <= end) {
int j = 2 * k + 1;
if (j + 1 <= end && nums[j + 1] > nums[j]) {
j++;
}
if (nums[j] > nums[k]) {
swap(nums, j, k);
} else {
break;
}
k = j;
}
}
private void swap(int[] nums, int index1, int index2) {
int temp = nums[index1];
nums[index1] = nums[index2];
nums[index2] = temp;
}
时间复杂度O(nlogn)
空间复杂度O(1)