堆排序/heapSort

void rebuildHeap(int a[], int p, int n) {
    int beforeChild=p<<1;
    if (n>beforeChild) {//ensure have children
        int l=1+beforeChild;
        int r=1+l;
        int pos=p;
        if (a[pos]<a[l]) {
            pos = l;
        }
        if (r<=n && a[pos]<a[r]) {
            pos = r;
        }
        if (pos>p) {
            int swap = a[p];
            a[p]=a[pos];
            a[pos]=swap;

            int deep=0;
            int new_n = pos;
            while(new_n<=n) {
                deep++;
                new_n = (new_n<<1)+1;//完全二叉树左侧最深
            }
            new_n = (1<<(deep-1)) -1 + ((new_n-1)>>1);
            new_n = new_n > n ? n : new_n;
            rebuildHeap(a, pos, new_n);
        }
    }
}

//n>0(index)
void buildHeap(int a[], int n) {
    int index = n;
    while (index>0) {
        int p = (index-1)>>1;
        int pos = p;
        if (a[pos]<a[index]) {
            //left or right child
            pos = index;
        }
        if (!(index&0x1) && (a[pos]<a[index-1])) {
            //has r child, reset index of l child to index-
            pos = index-1;
        }
    
        if (pos>p) {
            int swap = a[p];
            a[p] = a[pos];
            a[pos] = swap;

            int deep=0;
            int new_n = pos;
            while(new_n<=n) {
                deep++;
                new_n = (new_n<<1)+1;//完全二叉树左侧最深
            }
            new_n = (1<<(deep-1)) -1 + ((new_n-1)>>1);
            new_n = new_n > n ? n : new_n;

            rebuildHeap(a, pos, new_n);
        }
         index -= (index&0x1) ? 1 : 2;
        //index -= 2; //{1,2,3,4,6,5}
    }
}
void heapSort(int a[], int n) {

    if (n > 1) {
        buildHeap(a, n-1);
         do {
            int swap = a[0];
            a[0] = a[n-1];
            a[n-1] = swap;
            if (--n>1)
                rebuildHeap(a, 0, n-1);
         } while (n>1);
    }
}