[LeetCode] 116. Populating Next Right Pointers in Each Node

最新推荐文章于 2023-11-09 13:02:00 发布

原创最新推荐文章于 2023-11-09 13:02:00 发布 · 176 阅读

0 ·

CC 4.0 BY-SA版权

tree 专栏收录该内容

36 篇文章

订阅专栏

本文介绍了一种在二叉树中填充每个节点的next指针的方法，使其指向右侧相邻节点。提供了三种解决方案：使用队列的层次遍历、递归方法及仅使用常数额外空间的双指针技巧。

Populating Next Right Pointers in Each Node

Given a binary tree

struct TreeLinkNode {
TreeLinkNode *left;
TreeLinkNode *right;
TreeLinkNode *next;
}

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
Initially, all next pointers are set to NULL
Note:
You may only use constant extra space.
Recursive approach is fine, implicit stack space does not count as extra space for this problem.
You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).
Example:
这里写图片描述

解析

假设二叉树是满二叉树，即每个节点都有两个子节点，并且所有的叶子节点在同一层上，为每一个节点的next链接到相邻的右边节点上。

解法1：队列

如果存在子节点，把左节点的next连接到右节点；
如果节点的next不为空，把右节点的next链接到node->next->left，为空就链接到NULL。

class Solution {
public:
    void connect(TreeLinkNode *root) {
        queue<TreeLinkNode* > q;
        if(!root) return;
        q.push(root);
        while(!q.empty()){
            TreeLinkNode* node = q.front();
            q.pop();
            if(node->left && node->right){
                node->left->next = node->right;
                if(node->next)
                    node->right->next = node->next->left;
                else 
                    node->right->next = NULL;
                q.push(node->left);
                q.push(node->right);
            }
        }
    }
};

利用队列大小进行分层，层次遍历时当不为每一层的最后一个节点时，当前节点的next指向队列头指针。

class Solution {
public:
    void connect(TreeLinkNode *root) {
        if (!root) return;
        queue<TreeLinkNode*> q;
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                TreeLinkNode *t = q.front(); 
                q.pop();
                if (i < size - 1) {
                    t->next = q.front();
                }
                if (t->left) q.push(t->left);
                if (t->right) q.push(t->right);
            }
        }
    }
};

解法2：递归

直接递归判断左右子树并链接

class Solution {
public:
    void connect(TreeLinkNode *root) {
        if (!root) return;
        if (root->left && root->right) {
            root->left->next = root->right;
            root->right->next = root->next? root->next->left : NULL;
        }
        connect(root->left);
        connect(root->right);
    }
};

解法3：双指针，空间复杂度O(1)

用两个指针start和cur，其中start标记每一层的起始节点，cur用来遍历该层的节点。

class Solution {
public:
    void connect(TreeLinkNode *root) {
        if (!root) return;
        TreeLinkNode *start = root, *cur = NULL;
        while (start->left) {
            cur = start;
            while (cur) {
                cur->left->next = cur->right;
                if (cur->next) cur->right->next = cur->next->left;
                cur = cur->next;
            }
            start = start->left;
        }
    }
};

参考

http://www.cnblogs.com/grandyang/p/4288151.html