三大排序算法（归并，堆排，快排）

归并排序

归并排序

class Solution {
    public int reversePairs(int[] nums) {
        merge(nums, 0, nums.length - 1);
        return count;
    }

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

    public void mergeSort(int[] nums, int left, int mid, int right) {
        int[] temparr = new int[right - left + 1];
        int index = 0;
        int temp1 = left, temp2 = mid + 1;

        while (temp1 <= mid && temp2 <= right) {
            if (nums[temp1] <= nums[temp2]) {
                temparr[index++] = nums[temp1++];
            } else {
                temparr[index++] = nums[temp2++];
            }
        }
        //把左边剩余的数移入数组
        while (temp1 <= mid) {
            temparr[index++] = nums[temp1++];
        }
        //把右边剩余的数移入数组
        while (temp2 <= right) {
            temparr[index++] = nums[temp2++];
        }
        //把新数组中的数覆盖nums数组
        for (int k = 0; k < temparr.length; k++) {
            nums[k + left] = temparr[k];
        }
    }
}

堆排序

堆排序

import java.util.Arrays;
public class HeapSort {

    public static void main(String[] args) {
        int[] array = {4,6,1,2,9,8,3,5};
        heapSort(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 堆排序
     */
    public static void heapSort(int[] arr){
        //为什么从arr.length/2-1开始？
        for (int i = arr.length/2-1; i >= 0 ; i--) {
            adjustHeap(arr,i,arr.length);
        }

        for (int j = arr.length-1; j > 0; j--) {
            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            /*为什么从0开始？
                因为在第一次构建大顶堆后让堆顶元素和末尾元素进行交换
                而对于其他的非叶子结点所对应的子树都是大顶堆就无需调整，
                只需要堆顶元素(下标为0的非叶子结点)的子树调整成大顶堆
            */
            adjustHeap(arr,0,j);

        }
    }

    /**
     * 构建大顶堆
     * 注意：
     *      这个方法并不是将整个树调整成大顶堆
     *      而是以i对应的非叶子结点的子树调整成大顶堆
     * @param arr 待调整的数组
     * @param i 非叶子结点在数组中的索引(下标)
     * @param length 进行调整的元素的个数，length是在逐渐减少的
     */
    public static void adjustHeap (int[] arr,int i,int length){
        /*取出当前非叶子结点的值保到临时变量中*/
        int temp = arr[i];

        /*j=i*2+1表示的是i结点的左子结点*/
        for (int j = i * 2 + 1; j < length ; j = j * 2 + 1) {
            if (j+1 < length && arr[j] < arr[j+1]){ //左子结点小于右子结点
                j++; //j指向右子结点
            }
            if (arr[j] > temp){ //子节点大于父节点
                arr[i] = arr[j]; //把较大的值赋值给父节点
                //arr[j] = temp; 这里没必要换
                i = j; //让i指向与其换位的子结点 因为
            }else{
                /*子树已经是大顶堆了*/
                break;
            }
        }
        arr[i] = temp;
    }
}

快速排序

快排

package Sort;
 
public class 快速排序 {
	public static void main(String[] args) {
		int[] arr = {6,1,2,7,9,3,4,5,10,8};
		sort(arr, 0, arr.length-1);
		print(arr); 
	}
	
	public static void sort(int[] arr,int leftBound,int rightBound) {
		if(leftBound >= rightBound) return;
		int mid= partition(arr, leftBound, rightBound); //得到轴的位置
		sort(arr, leftBound, mid-1); //左边排序
		sort(arr, mid+1, rightBound); //右边排序
	}
	static int partition(int[] arr, int leftBound,int rightBound) {
		int pivot = arr[rightBound]; //指定数组最右边的数是用来比较的值 轴
		int left = leftBound;
		int right = rightBound - 1;
		
		while (left <= right) {
			while(left <= right && arr[left] <= pivot) left++;
			while(left <= right && arr[right] > pivot) right--;
			
			if (left < right) {
				//如果 左边的数比右边的数小  两个数交换
				swap(arr, left, right);
			}
		}
		//把left最后一次指向的位置与pivot（轴）的位置交换
		swap(arr, left, rightBound);
		
		return left; //返回轴的位置
	}
	
	static void swap(int[] arr,int i,int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	static void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}