LeetCode 116. 117. 填充每个节点的下一个右侧节点指针

116. 填充每个节点的下一个右侧节点指针

难度：中等。
标签：二叉树，深度优先搜索，广度优先搜索。

正确解法：

/*
// 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 {

    void build(Node* leftNode, Node* rightNode){
        if(leftNode == nullptr)return;
        leftNode->next = rightNode;
        build(leftNode->left, leftNode->right);
        build(leftNode->right, rightNode->left);
        build(rightNode->left, rightNode->right);
    }

public:
    Node* connect(Node* root) {
        if(root == nullptr)return nullptr;
        build(root->left, root->right);
        return root;
    }
};

结果：

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

难度：中等。
标签：二叉树，深度优先搜索，广度优先搜索。

用广搜就很好办。
先试试深搜，刚开始想判断一下left和right的子节点是不是空的，空的话就空过去，结果错误了，显然没有考虑到下列情况。

[1,2,3,4,5,null,6,7,null,null,null,null,8]

错误代码：

class Solution {

    void build(Node* leftNode, Node* rightNode){
        leftNode->next = rightNode;
        
        Node* node[4] = {leftNode->left, leftNode->right, rightNode->left, rightNode->right};
        for(int i = 0; i < 3; ++i){
            if(node[i] != nullptr){
                int j = i + 1;
                for(; j < 4; ++j){
                    if(node[j] != nullptr){
                        break;
                    }
                }
                if(j < 4){
                    build(node[i], node[j]);
                    i = j - 1;
                }
            }
        }
    }

public:
    Node* connect(Node* root) {
        if(root == nullptr)return nullptr;
        if(root->left != nullptr && root->right != nullptr){
            build(root->left, root->right);
        }
        return root;
    }
};

暂时想不到深搜的做法，先用广搜写一遍。时间空间复杂度都是O(N)。

正确解法：

class Solution {

public:
    Node* connect(Node* root) {
        if(root == nullptr)return nullptr;
        queue<Node*> que;
        que.push(root);

        while(!que.empty()){
            int size = que.size();
            Node* last = nullptr;
            for(int i = 0; i < size; ++i){
                Node* cur = que.front();
                que.pop();
                if(cur->left != nullptr)que.push(cur->left);
                if(cur->right != nullptr)que.push(cur->right);
                if(last != nullptr)last->next = cur;
                last = cur;
            }
        }
        
        return root;
    }
};

结果：

看题解，使用深搜的方法，空间复杂度是O(1)。
为了不使用queue，只要提前为每一层建立next指针的连接即可，使用next指针来遍历该层。
因此在第i层，为i+1层建立next指针。

正确解法：

class Solution {

    void traverse(Node* cur){
        if(cur == nullptr)return;
        Node* childHead = nullptr, *childLast = nullptr;
        while(cur != nullptr){
            if(cur->left != nullptr){
                if(childHead == nullptr){
                    childHead = cur->left;
                }
                if(childLast != nullptr)childLast->next = cur->left;
                childLast = cur->left;
            }
            if(cur->right != nullptr){
                if(childHead == nullptr){
                    childHead = cur->right;
                }
                if(childLast != nullptr)childLast->next = cur->right;
                childLast = cur->right;
            }
            cur = cur->next;
        }
        traverse(childHead);
    }

public:
    Node* connect(Node* root) {
        traverse(root);
        return root;
    }
};

结果：