117、填充每个节点的下一个右侧节点指针 II

给定一个二叉树

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

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

进阶：
	你只能使用常量级额外空间。
	使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

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

解题方法一：（迭代）层序遍历

/*
// 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) {
        if(!root) return root;

        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            int q_n = q.size();
            for(int i = 0; i < q_n; ++i){
                Node* node = q.front();
                q.pop();
                if(i < q_n - 1) node->next = q.front();

                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
        }
        return root;
    }
};

解题方法二：使用已经建立好的next指针

class Solution {
public:
    Node* connect(Node* root) {
        if(!root) return root;
        
        Node* cur = root;
        while(cur){
            Node* dummy = new Node(123); 	//在每一层的最前面添加一个哑节点
            Node* pre = dummy; 				//pre指针用于遍历cur所在层的子节点
            while(cur){
                if(cur->left){
                    pre->next = cur->left;
                    pre = pre->next;
                }
                if(cur->right){
                    pre->next = cur->right;
                    pre = pre->next;
                }
                cur = cur->next;
            }
            cur = dummy->next;
            delete dummy;
        }
        return root;
    }
};

解题方法三：递归

class Solution {
public:
	//一路向右找到有孩子的根节点
    Node* GetNext(Node* root){
        while(root->next){
            if(root->next->left){
                return root->next->left;
            }
            if(root->next->right){
                return root->next->right;
            }
            root = root->next;
        }
        return nullptr;
    }

    Node* connect(Node* root) {
        if(!root || (!root->left && !root->right)){
            return root;
        }
        if(root->left && root->right){
            root->left->next = root->right;
            root->right->next = GetNext(root);
        }
        if(!root->left){
            root->right->next = GetNext(root);
        }
        if(!root->right){
            root->left->next = GetNext(root);
        }
        root->right = connect(root->right);
        root->left = connect(root->left);

        return root;
    }
};