堆排序/归并排序

public static void main(String[] args) {
        int a[]=new int []{1,5,6,7,2,4,9,3,8};

        mergeSort(a,0,a.length-1);
        heapSort(a);
        System.out.println(Arrays.toString(a));

    }


//堆排序：大顶堆，利用二叉树的方式，依次交换到大顶堆
    public static void heapSort(int[] arr){
        for (int i = arr.length/2-1; i >= 0 ; i--) {   //第一个非叶子节点的索引就arr.length / 2 -1。
            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;
            adjustHeap(arr,0,j);

        }
    }


    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;
    }


    //归并排序：从中间分组，两边再分，拆成单个子序列，对子序列排序，合并
    public static int[] mergeSort(int[] a, int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
            mergeSort(a, low, mid);  // 左边归并排序
            mergeSort(a, mid + 1, high);  // 右边归并排序
            merge(a, low, mid, high);  // 合并两个有序数组
        }
        return a;
    }

    public static void merge(int[] a, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= high) {  // 对比大小，调整顺序
            if (a[i] < a[j]) {
                temp[k++] = a[i++];
            } else {
                temp[k++] = a[j++];
            }
        }
        // 左边剩余元素填充进temp中（因为前面已经归并，剩余的元素必会小于右边剩余的元素）
        while (i <= mid) {
            temp[k++] = a[i++];
        }
        // 右边剩余元素填充进temp中（因为前面已经归并，剩余的元素必会大于于左边剩余的元素）
        while (j <= high) {
            temp[k++] = a[j++];
        }
        // 调整数组顺序
        for (int x = 0; x < temp.length; x++) {
            a[x + low] = temp[x];
        }
    }