伪代码实现三种O(nlogn)排序算法（主要用于理解和记忆）

归并排序

public class MergeSort {

    //驱动程序
    public int[] mergeSort(参数) {
        //调用分治程序
        sort(A, 0, n-1);
        return A;
    }

    //分治程序
    sort(int[] data, int left, int right) {
        int middle = (left+right)/2;
        //分别调用
        sort(data, 0, middle);
        sort(data, middle+1, right);
        //合并
        merge(data, left, middle,right);    
    }

    //合并程序
    merge(int[] data, int left, int middle, int right) {
    1.创建大小为left-right+1的临时数组作为储存
    2.从前往后遍历左右两边的较小值放入临时数组
    3.将剩余的直接放入临时数组
    4.将临时数组放回原数组的相应位置
    }

}

快速排序

public class quickSort {

    //创建驱动程序
    public int[] quickSort(参数) {
        //调用分治程序
        quick(A, 0, n-1);
        return A;
    }   

    //创建分治程序
    public int[] quick(int[] A, int left, int right) {

        //首先判断left < right，避免数组越界

        //调用排序得到中点值进行分治
        int middle=sort(A, left, right);
        //进行左右分治
        quick(A, left, middle);
        quick(A, middle+1, right);

        return A;
    }

    //创建排序程序
    public int sort(int[] A, int left, int right) {

        int i = left, j = right;
        //首先判断left < right，避免数组越界

        //大循环
        while(left<right)　{
            1.拿到key=A[i]
            2.循环1，判断i<j&&key<=A[j]
            3.如果跳出循环，则表示A[j]<key,将A[j]放入A[i]拿出来的坑
            4.循环2，判断i<j&&A[i]<=key
            5.如果跳出循环，则表示A[i]>key，将A[i]放入A[j]拿出来的坑
            6.再次循环
        }

        将key放到排出来的A[i]坑，返回分割值i，即middle
    }


}

堆排序

public class HeapSort {

    //主程序
    public int[] heapSort(int[] A, int n) {

        //1.将传进来的数组重构成堆
        //从第一个非叶子节点开始即n/2-1
        for(int i=n/2-1;i>=0;i--) {
            heapAdjust(A, i, n-1);
        }   

        //2.从最后开始，逐渐缩小堆的范围，将已经排序好的数交换到最后
        int j = n-1;
        while(j>-1) {
            int tmp = A[j];
            A[j] = A[0];
            A[0] = tmp;
            //将0位置的数进行下滤
            heapAdjust(A, 0, j-1);
        }   
        return A;
    }

    //调整程序
    public void heapAdjust(int[] A, int begin, int length) {
        //判断左右child的大小，得到较大的与该节点比较
        int tmp = A[begin],child;
        //主要的循环，如果这次调整成功后则循环给下一个child进行调整，如果不需要调整则直接break本次循环
        for(int i=begin;i*2+1<=length;i=child) {
            child = i*2+1;
            if(child+1<=length && A[child+1]>A[child]) {
                child++;
            }
            if(A[child]>tmp) {
                A[i] = A[child];
            }else {
                break;
            }
            A[child] = tmp;
        }
    }
}