Add Sibling to Binary Tree

最新推荐文章于 2024-04-30 20:54:55 发布

转载最新推荐文章于 2024-04-30 20:54:55 发布 · 1.4k 阅读

C/C++语法的学习专栏收录该内容

65 篇文章

订阅专栏

本文介绍了一种高效算法，用于填充二叉树节点中的nextRight指针，以便于快速访问同一层级的相邻节点。算法首先采用广度优先搜索(BFS)方式实现，随后提出了改进方案，利用父节点的nextRight指针访问子节点，最后简化为递归形式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Question:
Given a binary tree

struct Node {
Node* leftChild;
Node* rightChild;
Node* nextRight;
}
Populate the nextRight pointers in each node.

The first idea come out should be the BFS tree algorithm, which can traverse the binary tree layer by layer. We only need to connect the sibling for each layer.

<pre>int
populateNextRightBFS(Node* root) {
    if
(!root)
        return
0;
    queue <Node*> q;
    q.push(root);
    int
nextLayer = 0;
    int
curLayer = 1;
    Node* prev = NULL;
    while
(!queue.empty()) {
        Node* cur = queue.front();
        if
(prev)
            prev->sibling = cur;
        if
(cur->left) {
            queue.push(cur->left);
            nextLayer++;
        }
        if
(cur->right) {
            queue.push(cur->right);
            nextLayer++;
        }
        queue.pop();
        curLayer--;
        prev = cur;
        if
(!curLayer) {
            curLayer = nextLayer;
            nextLayer = 0;
            prev = NULL;
        }
    }
    return
0;
}

Above algorithm uses an queue, which can be saved actually. We could use the parent’s sibling to visit children’ siblings. Then we have the following algorithm.

<pre>int
populateNextRightExt(Node* root) {
    if
(!root)
        return
0;
 
    if
(root->left)
        root->left->sibling= root->right;
    Node* cur = root;
    if
(root->right) {
        while
(cur->sibling && !cur->sibling->left && !cur->sibling->right)
            cur = cur->sibling;
        if
(cur->sibling && cur->sibling->left)
            root->right->sibling = cur->sibling->left;
        else
if 
(cur->sibling && cur->sibling->right)
            root->right->sibling = cur->sibling->left;
        else
            root->right->sibling = NULL;
    }
 
    populateNextRight(root->right);
    populateNextRight(root->left);
 
    return
0;
}

P.S If the sibling only points to the node in one-step right, and NULL otherwise, we do not need to search for its sibling far away. The simplified algorithm is as follows.

<pre>int
populateNextRight(Node* root) {
    if
(!root)
        return
0;
 
    if
(root->left)
        root->left->sibling= root->right;
    if
(root->right)
        root->right->sibling = (root->sibling) ? root->sibling->left : NULL;
 
    populateNextRight(root->right);
    populateNextRight(root->left);
 
    return
0;
}