public static void heapSort(int[] A) {
        int len = A.length;
        int start = len / 2 - 1;

        for (int i = start; i >= 0; --i) {
            siftDown(A, i);
        }
    }

    private static void siftDown(int[] A, int start) {
        int len = A.length;
        boolean needAdust = true
 
;
        int pos = 0;
        while (needAdust) {
            if (!isLeaf(start, len)) {
                int left = A[2 * start + 1];
                if (2 * start + 2 < len) {
                    int right = A[2 * start + 2];

                    if (left < right && left < A[start]) {
                        pos = 2
 
 * start + 1;
                    } else if (right < left && right < A[start]) {
                        pos = 2 * start + 2;
                    } else {
                        needAdust = false;
                    }

                    if (needAdust) {
                        swap(A, start, pos);
                        start = pos;
                    }

                } else
 
 {
                    if (left < A[start]) {
                        swap(A, start, 2 * start + 1);
                        return;
                    } else {
                        needAdust = false;
                    }

                }
            } else {
                needAdust = false;
            }
        }
    }

    private static void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }

    private static boolean isLeaf(int pos, int len) {
        int max = len / 2 - 1;
        if (pos > max) {
            return true;
        }
        return false;
    }