堆排序

/**
     * 可以用一维数组表示堆heap，但是并不是一维数组就是堆。要成为堆必须具备一个性质： 数组中的元素满足，k[i]<=k[2*i] &&
     * k[i]<=k[2*i+1]
     * 如果当前堆的的根节点为堆中的最大值，而其他的左右孩子节点都不大于父节点，则称该堆为大根堆。同理，小根堆为根节点为堆中的最小值
     * ，而左右孩子节点均不小于父节点。
     * 
     * @param pArr
     */
    static void heapSort(int[] pArr) {
        for(int i=0,len=pArr.length;i<len;i++){
            heapAdjust(pArr, i);
        }
    }
    /**
     * 这里要注意堆调整时，是根据数组中开始下标进行决定的。
     * @param pArr
     * @param s
     */
    static void heapAdjust(int[] pArr, int s) {
        int tmp = 0, len = pArr.length - 1;
        int i = len;
        while (i > s) {
            int k = (i-s-1) / 2+s; // 找父节点,(i-s-1) / 2在当前虚拟子树中的父节点在数组中的位置，(i-s-1) / 2+s为在pArr中数组的下标值。
            if (!lt(pArr[i], pArr[k])) {
                // 调整父节点
                tmp = pArr[i]; 
                pArr[i] = pArr[k];
                pArr[k] = tmp;

                //调整子节点
                if ((2 * i + 1-s) < len && !lt(pArr[2 * i + 1-s], pArr[i])) {//找左孩子
                    tmp = pArr[i];
                    pArr[i] = pArr[2 * i + 1];
                    pArr[2 * i + 1] = tmp;
                }
                if ((2 * i + 2-s) < len && !lt(pArr[2 * i + 2-s], pArr[i])) {//找右孩子
                    tmp = pArr[i];
                    pArr[i] = pArr[2 * i + 2-s];
                    pArr[2 * i + 2-s] = tmp;
                }
            }
            i--;
        }
    }

    static void array2LitterHeap(int[] pArr) {
        int tmp = 0, len = pArr.length - 1;
        int i = len;
        while (i > 0) {
            int k = (i - 1) / 2;
            if (lt(pArr[i], pArr[k])) {
                tmp = pArr[i];
                pArr[i] = pArr[k];
                pArr[k] = tmp;
                if ((2 * i + 1) < len && lt(pArr[2 * i + 1], pArr[i])) {
                    tmp = pArr[i];
                    pArr[i] = pArr[2 * i + 1];
                    pArr[2 * i + 1] = tmp;
                }
                if ((2 * i + 2) < len && lt(pArr[2 * i + 2], pArr[i])) {
                    tmp = pArr[i];
                    pArr[i] = pArr[2 * i + 2];
                    pArr[2 * i + 2] = tmp;
                }
            }
            i--;
        }
    }

    static void array2BiggerHeap(int[] pArr) {
        int tmp = 0, len = pArr.length - 1;
        int i = len;
        while (i > 0) {
            int k = (i - 1) / 2;
            if (!lt(pArr[i], pArr[k])) {
                tmp = pArr[i];
                pArr[i] = pArr[k];
                pArr[k] = tmp;
                if ((2 * i + 1) < len && !lt(pArr[2 * i + 1], pArr[i])) {
                    tmp = pArr[i];
                    pArr[i] = pArr[2 * i + 1];
                    pArr[2 * i + 1] = tmp;
                }
                if ((2 * i + 2) < len && !lt(pArr[2 * i + 2], pArr[i])) {
                    tmp = pArr[i];
                    pArr[i] = pArr[2 * i + 2];
                    pArr[2 * i + 2] = tmp;
                }
            }
            i--;
        }
    }

    private static boolean lt(int i, int j) {
        return i - j <= 0 ? true : false;
    }

    static void print(int[] pArr) {
        for (int var : pArr) {
            System.out.print(var + "  ");
        }
    }