堆排序

堆

性质：

最大堆性质：除根节点以外的所有节点i，都要满足节点i必须小于等于它的父节点

最小堆性质：除根节点以外的所有节点i，都要满足节点i必须大于等于它的父节点

属性:

节点的高度：为该节点到叶节点最长简单路径上边的数目

方法：

最大（小）堆	解释
MAX-HEAPIFY(MIN-HEAPIFY)	维护堆得性质
BUILD-MAX-HEAP(BUILD-MAX-HEAP)	建堆
HEAPSORT(HEAPSORT)	堆排序

代码实现

void MinHeapify(vector &A, int i) {
    int l = LEFT(i);   // 左孩子节点
    int r = RIGHT(i);  //右孩子节点
    int Smallest;
    if (l <= HeapSize && A[l-1] < A[i]) {
        Smallest = l - 1;
    } else {
        Smallest = i;
    }
    if (r <= HeapSize && A[r-1] < A[Smallest]) {
        Smallest = r - 1;
    {
        //上面三个用于比较该节点与它的孩子节点哪个更小
    if (smallest != i) {    //如果smallest与该节点相同，表示该节点符合最小堆性质
        Exchange(A, i, smallest);  // 交换
        MinHeapify(A, smallest);  //继续判断交换后是否满足最小堆性质
    }
}

void BuildMinHeap(vector &A) {
        /*从底向上依次维护最小堆性质, 因为HeapSize/2之后的元素都是叶节点，
        无孩子节点，故无需考虑调用MinHeapify()*/
    for (int i = HeapSize/2 - 1; i >= 0; i--) {
        MinHeapify(A, i);
    }
}

void HeapSort(vector &A) {
    BuildMinHeap(A);
        // 依次把最小元素放置数组A的最后面，并
    for (int i = HeapSize - 1; i > 0; i--) {
        Exchange(A, 0, i);
        HeapSize -= 1;
        MinHeapify(A, 0);
    }
}

优先队列

性质：继承堆得性质，优先队列中每一个元素都有一个相关的值，称为关键字

属性：继承堆得性质

方法:

最小优先队列	解释
INSERT(S, x)	把元素x插入堆中
MINIMUM(S)	返回堆中关键字最小值的元素
EXTRACT-MAX(S)	返回并去除关键字值最小的元素
INCREASE_KEY(S, x, k)	将元素x的关键字值增加到k，这里假设k的值不小于x的关键字值

int HeapExtractMin(vector &A) {
    int min = A[0];
    A[0] = A[HeapSize];
    HeapSize -= 1;
    MinHeapify(A, 0);
    return min;
}

void HeapIncreaseKey(vector &A, int i, int key) {
    if (key < A[i]) {
        std::cout<<"new key is smaller than current key";
    }
    A[i] = key;
    while (i > 0 && A[PARENT(i) - 1] < A[i]) {
        Exchange(A, i, PARENT(i) - 1);
        i = PARENT(i) - 1;
    }
}

void MaxHeapInsert(vector &A, int key) {
    HeapSize -= 1;;
    A[HeapSize - 1] = -INFINITTY;
    HeapIncreaseKey(A, HeapSize, key);
}

int Minimum(vector A) {
        return A[0];
}