LeetCod#116.填充每个节点的下一个右侧节点指针-CSDN博客

本文链接：https://blog.csdn.net/weixin_37549298/article/details/106639020

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例：

输入：{“ $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots":"1","left":{"$ id”:“2”,“left”:{“ $KaTeX parse error: Expected 'EOF', got '}' at position 53: \dotst":null,"val":4}̲,"next":null,"r\dots$ id”:“4”,“left”:null,“next”:null,“right”:null,“val”:5},“val”:2},“next”:null,“right”:{“ $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots":"5","left":{"$ id”:“6”,“left”:null,“next”:null,“right”:null,“val”:6},“next”:null,“right”:{"$id":“7”,“left”:null,“next”:null,“right”:null,“val”:7},“val”:3},“val”:1}

输出：{“ $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots":"1","left":{"$ id”:“2”,“left”:{“ $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots:null,"next":{"$ id”:“4”,“left”:null,“next”:{“ $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots:null,"next":{"$ id”:“6”,“left”:null,“next”:null,“right”:null,“val”:7},“right”:null,“val”:6},“right”:null,“val”:5},“right”:null,“val”:4},“next”:{“ $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots":"7","left":{"$ ref”:“5”},“next”:null,“right”:{“ $KaTeX parse error: Expected 'EOF', got '}' at position 9: ref":"6"}̲,"val":3},"righ\dots$ ref”:“4”},“val”:2},“next”:null,“right”:{"$ref":“7”},“val”:1}

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法：总体上思路就是如果是根节点就不用处理，如果是左孩子就指向右孩子，如果是右孩子就指向起父的next的左孩子，但是要起父有next。

如果采用的是层次遍历，也可以一层一层处理吧

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        //也可以采用先序遍历
        //根节点不做处理，其他节点都是左指右，右指父的next的左
        connectCore(root,nullptr);
        return root;
    }
    void connectCore(Node* root,Node* father){
        if(root){
            if(father){
               if(root == father->left){
                   //左孩子
                   root->next = father->right;
               } else{
                   //右孩子
                   if(father->next)
                        root->next = father->next->left;
               }
            }
            connectCore(root->left,root);
            connectCore(root->right,root); 
        }
    }
    Node* connect1(Node* root) {
        //二叉树的层次遍历
        //需要用队列来存
        if(root == nullptr || (root->left == nullptr && root->right == nullptr))return root;
        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            Node *tmp = q.front();
            q.pop();
            if(tmp->left){
                //那么左孩子的next就是右孩子、
                tmp->left->next = tmp->right;
                q.push(tmp->left);
            } 
            if(tmp->right){
                //如果有右孩子，则next就是父的next的左孩子
                if(tmp->next)
                    tmp->right->next = tmp->next->left;
                q.push(tmp->right);
            } 
        }
        return root;
    }
};