序

GitHub 见solution.txt

6.1 堆

6.1-1

在高度为h的堆中，最多元素为$2 ^(h+1)-1$个，最少元素有 $2^h+1$ 个

6.1-3

最大堆的特性是除了根结点外的每个结点都有$A[PARENT(i)]>=A[i]$故，在一个最大堆的某颗子树中最大元素必然位于该子树的根上。

6.1-4

根据最大堆的性质，任何子树的子结点都小于根节点，故整棵树的最小元素必然位于堆的最底层或者倒数第二层的叶子结点。

6.1-5

不一定，是最小堆也可能是最大堆

6.1-6

不是，画出相应堆结构发现元素7是元素6的右孩子，$7>6$，不满足最大堆性质。

6.1-7

证明，当用数组表示存储了$n$个元素的堆时，
除根节点，满足

PARENT(i)
    return i/2

除叶子结点，满足

LEFT(i)
    return 2*i
RIGHT(i)
    return 2*i+1

堆中，最大根节点的下标为 $floor(n/2)$ ，因此数组中下标在 $n/2$ 后的元素
将都是堆中的叶子结点。

6.2 保持堆的性质

6.2-2

C++代码如下：

void minHeapify(int *data, int i)
{
    int minPos;
    int left = Left(i);
    int right = Right(i);

    if (left <= m_heapSize && data[left-1] < data[i-1])
        minPos = left;
    else
        minPos = i;

    if (right <= m_heapSize && data[right-1] < data[minPos-1])
        minPos = right;

    if (minPos != i)
    {
        swap(data[i - 1], data[minPos - 1]);
        minHeapify(data, minPos);
    }
}

6.2-3

直接返回

6.2-4

此时i结点没有左右孩子，函数直接返回

6.2-5

迭代实现的manHeapify

void MaxHeap::maxHeapify(int *data, int i)
{
    int largest;

    int left = Left(i);
    int right = Right(i);

    if (left <= m_heapSize && data[left-1] > data[i-1])
        largest = left;
    else
        largest = i;

    if (right <= m_heapSize && data[right-1] > data[largest-1])
        largest = right;

    while(largest != i)
    {
        swap(data[i - 1], data[largest - 1]);
        i = largest;
        left = Left(i);
        right = Right(i);

        if (left <= m_heapSize && data[left-1] > data[i-1])
            largest = left;
        else
            largest = i;
        if (right <= m_heapSize && data[right-1] > data[largest-1])
            largest = right;
    }
}

6.2-6

对于一个大小为$n$个堆，MaxHeapify函数每处理一次结点高度$+1$，最坏情况下，函数处理从根节点至最大叶节点，为整个树的高度$logn$，因此函数最坏运行时间也为$(logn)$

6.3 建堆

6.3-2

[待补充]

6.3-3

参考

6.4 堆排序算法

6.4-2

堆排序算法HeapSort输入是一个大顶堆，输出是一个递增有序序列，由图6-4所示每次执行完该算法的2~5行迭代时，子数组$A[1~i]$中即是已排好序的i个元素，而此时$A[i+1~n]$中是其余$n-i$个元素构成的大顶堆，也是数组A中$n-i$个最大元素。

6.4-3

对于$n$个递增数组A，堆排序$T(n)=o(nlogn)$
对于$n$个递减数组A，堆排序$T(n)=o(n)$

6.4-4

堆排序算法中，对A中每个元素最多处理一次：
（1）取下头结点，$O(1)$
（2）把最后一个结点移到根结点位置，$O(1)$
（3）对该结点执行MAX-HEAPIFY，最坏时间为$O(lgn)$
对每个结点处理的最坏时间是$O(lgn)$，每个结点最多处理一次。
因此堆排序的最坏情况运行时间为$floor(nlogn)$

6.5 优先级队列

未完待续 ^||^ ~~~

思考题

未完待续 ^||^ ~~~