堆排序（大顶堆、小顶堆）

https://www.cnblogs.com/lanhaicode/p/10546257.html

概念

大顶堆：每个结点的值都大于或等于其左右孩子结点的值

小顶堆：每个结点的值都小于或等于其左右孩子结点的值

按层编号

 

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] 

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

 

思路

堆排序：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值，如此反复。

int a[6] = {7, 3, 8, 5, 1, 2};

升序----使用大顶堆

降序----使用小顶堆

 

交换过程

先要找到最后一个非叶子节点，数组的长度为6，那么最后一个非叶子节点就是：长度/2-1，也就是6/2-1=2，然后下一步就是比较该节点值和它的子树值，如果该节点小于其左\右子树的值就交换（意思就是将最大的值放到该节点）。

下一步，继续找到下一个非叶子节点（其实就是当前坐标-1就行了），该节点的值为3小于其左子树的值，交换值，交换后该节点值为5，大于其右子树的值，不需要交换

下一步，继续找到下一个非叶子节点，该节点的值为7，大于其左子树的值，不需要交换，再看右子树，该节点的值小于右子树的值，需要交换值

下一步，检查调整后的子树，是否满足大顶堆性质，如果不满足则继续调整（这里因为只将右子树的值与根节点互换，只需要检查右子树是否满足，而8>2刚好满足大顶堆的性质，就不需要调整了，

如果运气不好整个数的根节点的值是1，那么就还需要调整右子树）。

到这里大顶堆的构建就算完成了，然后下一步交换根节点（8）与最后一个元素（2）交换位置（将最大元素"沉"到数组末端），此时最大的元素就归位了，然后对剩下的5个元素重复上面的操作

剩下只有5个元素，最后一个非叶子节点是5/2-1=1，该节点的值（5）大于左子树的值（3）也大于右子树的值（1），满足大顶堆性质不需要交换

找到下一个非叶子节点，该节点的值（2）小于左子树的值（5），交换值，交换后左子树不再满足大顶堆的性质再调整左子树，左子树满足要求后再返回去看根节点，根节点的值（5）小于右子树的值（7），再次交换值

得到新的大顶堆，如下图，再把根节点的值（7）与当前数组最后一个元素值（1）交换，再重构大顶堆->交换值->重构大顶堆->交换值····，直到整个数组都变成有序序列

最后得到的升序序列如下图

 

代码实现

#include 

void Swap(int *heap, int len);         /* 交换根节点和数组末尾元素的值 */
void BuildMaxHeap(int *heap, int len); /* 构建大顶堆 */

int main()
{
    int a[6] = {7, 3, 8, 5, 1, 2};
    int len = 6;    /* 数组长度 */
    int i;

    for (i = len; i > 0; i--)
    {
        BuildMaxHeap(a, i);
        Swap(a, i);
    }
    for (i = 0; i < len; i++)
    {
        printf("%d ", a[i]);
    }

    return 0;
}
/* Function: 构建大顶堆 */
void BuildMaxHeap(int *heap, int len)
{
    int i;
    int temp;

    for (i = len/2-1; i >= 0; i--)
    {
        if ((2*i+1) < len && heap[i] < heap[2*i+1])    /* 根节点大于左子树 */
        {
            temp = heap[i];
            heap[i] = heap[2*i+1];
            heap[2*i+1] = temp;
            /* 检查交换后的左子树是否满足大顶堆性质 如果不满足 则重新调整子树结构 */
            if ((2*(2*i+1)+1 < len && heap[2*i+1] < heap[2*(2*i+1)+1]) || (2*(2*i+1)+2 < len && heap[2*i+1] < heap[2*(2*i+1)+2]))
            {
                BuildMaxHeap(heap, len);
            }
        }
        if ((2*i+2) < len && heap[i] < heap[2*i+2])    /* 根节点大于右子树 */
        {
            temp = heap[i];
            heap[i] = heap[2*i+2];
            heap[2*i+2] = temp;
            /* 检查交换后的右子树是否满足大顶堆性质 如果不满足 则重新调整子树结构 */
            if ((2*(2*i+2)+1 < len && heap[2*i+2] < heap[2*(2*i+2)+1]) || (2*(2*i+2)+2 < len && heap[2*i+2] < heap[2*(2*i+2)+2]))
            {
                BuildMaxHeap(heap, len);
            }
        }
    }
}

/* Function: 交换交换根节点和数组末尾元素的值*/
void Swap(int *heap, int len)
{
    int temp;

    temp = heap[0];
    heap[0] = heap[len-1];
    heap[len-1] = temp;
}