是的，这个算法相对简单，注意当考虑一个索引为i的项时，它在堆中的“父项”位于索引(i-1)/2，它的子项位于索引i*2+1和i*2+2。
1.用item_to_pop交换范围内的最后一个项。这会将该项移动到所需的（最后一个）位置，但会在堆的中间插入一个“小”项。这需要修复。
1.如果item_to_pop位置上的“small”项大于它的当前父项，则与它的父项进行交换。重复操作，直到该项不再大于它的当前父项或者成为新的根。然后我们就完成了。值得注意的是，这与push_heap的算法相同，只是我们从中间而不是从末尾开始的快捷方式不同。
1.如果item_to_pop位置的“small”项小于 * 任一个 * 当前子项，则与 larger 子项交换。重复此操作，直到该项大于其任何当前子项（注意到最后可能只有一个孩子或者没有孩子）。然后我们就完成了。值得注意的是，这是与pop_heap相同的算法，除了我们从中间而不是顶部开始的捷径。
这个算法最多可以执行log2(n)+1交换和log2(n)*2+1比较，这使得它几乎和pop_heap和push_heap一样快，这并不奇怪，因为它是同一个算法。

template< class RandomIt, class Compare >
constexpr void pop_mid_heap(RandomIt first, RandomIt last, RandomIt item_to_pop, Compare comp) {
    assert(std::is_heap(first, last)); //this is compiled out of release builds
    assert(first<=item_to_pop);
    assert(item_to_pop<last);
    using std::swap;
    std::size_t new_size = last - first - 1;
    if (new_size == 0) return;
    //swap the end of the range and item_to_pop, so that item_to_pop is at the end
    swap(*item_to_pop, *--last);
    if (new_size == 1) return;
    //If item_to_pop is bigger than it's parent, then swap with the parent
    bool moved_up = false;
    RandomIt swap_itr;
    while (true) {
        std::size_t offset = item_to_pop - first;
        if (offset == 0) break; //item_to_pop is at root: exit loop 
        swap_itr = first + (offset-1) / 2;
        if (comp(*item_to_pop, *swap_itr)) 
            break; //item_to_pop smaller than it's parent: exit loop
        swap(*item_to_pop, *swap_itr); //swap with parent and repeat
        item_to_pop = swap_itr;
        moved_up = true;        
    }
    if (moved_up) return; //if we moved the item up, then heap is complete: exit
    //If biggest child is bigger than item_to_pop, then swap with that child
    while (true) {
        std::size_t offset = item_to_pop - first;
        std::size_t swap_idx = offset * 2 + 1;
        if (swap_idx >= new_size) break; //no children: exit loop
        swap_itr = first + swap_idx;
        if (swap_idx+1 < new_size && comp(*swap_itr, *(swap_itr+1))) //if right child exists and is bigger, swap that instead
            ++swap_itr;
        if (!comp(item_to_pop, swap_itr)) break; //item_to_pop bigger than biggest child: exit loop
        swap(*item_to_pop, *swap_itr); //swap with bigger child and repeat
        item_to_pop = swap_itr;
    }
}
template< class RandomIt >
constexpr void pop_mid_heap(RandomIt first, RandomIt last, RandomIt item_to_pop) {
    pop_mid_heap(first, last, item_to_pop, std::less<>{});
}

https://ideone.com/zNW7h7
理论上，可以优化push_heap部分中的“or is the new root”检查，但是用于检测这种情况的检查增加了复杂性，似乎不值得这样做。
IMO，这很有用，应该成为C++标准库的一部分。

一般来说，在二进制堆中间更新节点的代价很高，不是因为更新操作代价高，而是因为 * 查找 * 节点是一个O（n）操作。如果你知道节点在堆中的位置，更新它的优先级非常容易。我在https://stackoverflow.com/a/8706363/56778中的答案显示了如何删除节点。更新节点的优先级类似于：不是用堆中的最后一个节点替换该节点，而是根据需要向上或向下筛选该节点。
如果你想快速找到一个节点，那么你必须建立一个索引堆，基本上，你有一个字典条目为每个节点，字典键是节点的ID（或任何你用来识别它的东西），值是该节点在二进制堆中的索引，修改堆代码，使其在节点在堆中移动时更新字典条目。它使堆稍微慢了一点（按常数因子），但使查找任意节点成为O（1）操作。
或者，可以用Pairing Heap、skip list或其他任何使用节点指针的“堆”类型来替换二进制堆，我的经验是，尽管这两种堆的理论性能不如Fibonacci堆，但实际性能要好得多。
有了这两种方法，维护索引就容易多了：当你向堆中添加一个节点时，你只需要添加一个节点引用，当节点从堆中移除时，你只需要移除一个引用。这两种堆类型都很容易构建，性能和二进制堆差不多，尽管它们会使用更多的内存。根据经验，我会说配对堆比跳跃列表更容易构建，但是跳跃列表是一种更常用的数据结构。