Question

我试图在堆的最后一级（树表示）中找到最右边的节点，以便删除最小/最大堆中的特定元素。

几乎所有地方的在线人士都写过用最低的堆中最右边的节点替换要删除的节点的方法-我完全理解，但是如何找到最后一个节点？

根据我的解决方案：我有一个解决方案，即在存储节点地址的同时使用级别顺序遍历（广度优先搜索）遍历该树（堆结构）队列中只剩下一个没有子节点的元素，我将用它替换。在此示例中，最右边的节点是 33 ：

还有其他可以使用队列的方法/链接吗？

Answer 1

让我们看一看完整的二叉树，忽略存储在节点上的值，但是对节点as if they were stored in an array进行编号，从根的编号开始： Binary heap tree 如果我们从根遍历到任何目标节点（根本身除外），其左边缘（红色）为0，右边缘（蓝色）为1，我们将看到一个模式：

Path     Edges   Target (binary)
─────    ──────  ───────────────
1 → 2    0       1 0
1 → 3    1       1 1
1 → 4    0 0     1 0 0
1 → 5    0 1     1 0 1
1 → 6    1 0     1 1 0
1 → 7    1 1     1 1 1
1 → 8    0 0 0   1 0 0 0
1 → 9    0 0 1   1 0 0 1
1 → 10   0 1 0   1 0 1 0
1 → 11   0 1 1   1 0 1 1
1 → 12   1 0 0   1 1 0 0
1 → 13   1 0 1   1 1 0 1
1 → 14   1 1 0   1 1 1 0
1 → 15   1 1 1   1 1 1 1

从根到所需节点的路径与该节点号的二进制表示形式相同（根为1），而忽略了最高有效的二进制数字！

因此，在一棵完整的树中，要到达第K个节点，其根为1，我们首先找到小于K的2的最大幂，然后根据二进制数字遍历在其下方，按降序排列，零表示左，右表示一。

假设我们的节点结构类似

typedef  struct node  node;
struct node {
    struct node  *left;
    struct node  *right;
    /* plus node data fields */
};

然后找到第i个节点，i = 1作为根，可以实现为

node *ith_node(node *root, const size_t i)
{
    size_t  b = i; 

    /* Sanity check: If no tree, always return NULL. */
    if (!root || i < 1)
        return NULL;

    /* If i is 1, we return the root. */
    if (i == 1)
        return root;

    /* Set b to the value of the most significant binary digit
       set in b. This is a known trick. */
    while (b & (b - 1))
        b &= b - 1;        

    /* We ignore that highest binary digit. */
    b >>= 1;

    /* Walk down the tree as directed by b. */
    while (b) {
        if (i & b) {
            if (root->right)
                root = root->right;
            else
                return NULL; /* Not a complete tree, or outside the tree. */
        } else {
            if (root->left)
                root = root->left;
            else
                return NULL; /* Not a complete tree, or outside the tree. */
        }

        /* Next step. */
        b >>= 1;
    }

    /* This is where we arrived at. */
    return root;
}

实际上，如果您有一个带有N个节点的完整二叉树，则ith_node(root, N)将返回一个指向最终节点的指针。

如果您想要的路径是最低有效位是从根开始的第一个边，则可以使用例如

/* (*path) will contain the path to ith node, root being i=1,
   and the return value is the number of steps needed.
   Returns -1 if an error occurs. */
int  path_to_ith(const size_t i, size_t *path)
{
    size_t  b = i;
    size_t  p = 0;
    int     n = 0;

    if (i < 1)
        return -1; /* Invalid i! */

    /* Set b to the value of the most significant binary digit set. */
    while (b & (b - 1))
        b &= b - 1;        

    /* Ignore most significant digit. */
    b >>= 1;

    /* Reverse the rest of the bits in b, into p. */
    while (b) {
        p = (p << 1) + (b & 1);
        b >>= 1;
        n++;
    }

    /* Store path. */
    if (path)
        *path = p;

    /* Return the number of edges (bits) in path. */
    return n;
}

请注意，上面的功能基于完整的树：即，除了可能的最后一个级别之外的所有级别都已填充，最后一个级别已填充了所有最左边的节点。也就是说，如果使用上图所示的编号填充节点N，则还必须填充节点1到N-1。

以上示例中的逻辑有效。但是，由于示例代码是在没有适当审查的情况下编写的，因此其中可能存在错误。因此，如果您对示例代码或该答案中的任何地方有任何疑问，请在评论中告知我，以便我可以根据需要进行检查和修复。

请注意，二进制堆通常使用数组表示。

（要使用适当的数组索引，我们在这里切换到从零开始的索引；即从这一点开始，根在索引0处。）

然后，节点没有指针。为了支持删除，我们通常将索引存储到节点所在的堆数组中，否则节点仅包含数据。（如果您需要更改键值或删除除根目录以外的条目，通常会添加一个指定当前堆数组索引的数据字段。不过这样做会使速度变慢，因此通常不需要这样做。我将省略它为简单起见。）

typedef  double  heap_key;

typedef struct {
    /* Data only! */
} heap_data;

typedef struct {
    heap_key   key;
    heap_data *val;
} reference;

typedef struct {
    size_t     max;  /* Current max heap size, nodes */
    size_t     len;  /* Number of nodes in this heap */
    reference *ref;  /* Array of references to nodes */
} heap;
#define  HEAP_INIT { 0, 0, NULL }

static inline void heap_init(heap *h)
{
    if (h) {
        h->max = 0;
        h->len = 0;
        h->ref = NULL;
    }
}

请注意，heap中的引用数组是根据需要动态分配/重新分配的，因此对堆的大小（当然不是内存）没有固有的限制。

HEAP_INIT宏允许在声明时初始化堆。换句话说，heap h = HEAP_INIT;等效于heap h; heap_init(&h);。

在这样的堆中添加新元素非常简单：

static int heap_add(heap *h, heap_data *d, const heap_key k)
{
    size_t  i;

    if (!h)
        return -1; /* No heap specified. */

    /* Ensure there is room for at least one more entry. */
    if (h->len >= h->max) {
        size_t     max;
        reference *ref;

        /* Minimum size is 15 references; then double up
           to 1966080 entries; then set next multiple of
           1024*1024 + 1024*1024-2. */
        if (h->len < 15)
            max = 15;
        else
        if (h->len < 1966080)
            max = 2 * h->len;
        else
            max = (h->len | 1048575) + 1048574;

        ref = realloc(h->ref, max * sizeof h->ref[0]);
        if (!ref)
            return -2; /* Out of memory; cannot add more. */

        h->max = max; 
        h->ref = ref;
    }

    i = h->len++;
    h->ref[i].key = key;
    h->ref[i].val = data;

    /* Omitted:  Percolate 'i' towards root,
                 keeping the heap order property for keys. */

    /* if (!i) "i is root";
       For all other cases, the parent is at index ((i-1)/2), and
       if (i&1) "i is a left child, sibling is (i+1)";
       else     "i is a right child, sibling is (i-1)";
    */

    return 0;
}

在堆数组中，如果您有n个节点，则索引为i（根索引为0）的节点具有

当且仅当(i - 1)/2

i > 0

当且仅当2*i+1

2*i+1 < n

当且仅当2*i+2

2*i+2 < n

级别为k的节点的索引是连续的，从(1 << k) - 1到(2 << k) - 2（含）（当根具有索引0和级别0时）。

索引为i（根的索引为0且级别为0）的节点处于级别k，为floor(log2(i+1))或通过例如以下函数获得：

static inline size_t  ith_level(size_t  i)
{
    size_t  n = 0;
    size_t  t = (i + 1) / 2;

    while (t) {
        t >>= 1;
        n++;
    }

    return n;
}

同样，以上示例中的逻辑有效。但是，由于示例代码是在没有适当审查的情况下编写的，因此其中可能存在错误。因此，如果您对示例代码或该答案中的任何地方有任何疑问，请在评论中告知我，以便我可以根据需要进行检查和修复。

如何在树的最后一层（堆）（最后是完整的树）上找到最后（最右边）的节点？

1 个答案: