LeetCode117.填充每个节点的下一个右侧节点指针 II（思维+dfs）

题目链接：leetcode117

题面

题目大意

给你一个二叉树，树节点指针域中多给了一个next指针，让你在时间复杂度尽可能优的情况下把每层的节点利用next指针串成一个链表。

解题思路

BFS（二叉树层次遍历）

利用队列，额外维护一个树的高度，之后按高度把每层的next指针串连起来。但由于使用到额外的空间，显然不是本题的最优解。

时间复杂度：$O(n)$，空间复杂度：$O(n)$。

DFS+栈

我们不难发现，需要处理 next 指针的节点除了整棵树的最右侧链外其余均需要。而对于一个链表的构造我们除了正常顺序的尾插，也可以使用头插。对于这边我们考虑，对于任意一棵子树，我们都从右往左进行处理，相当于先遍历树的右侧链，然后不断往左，相当于我们把树按右侧链进行划分，从右到左的右侧链进行头插（反向头插和正向尾插等价）。

对于一个右侧链的信息我们可以在递归的过程中维护一个公共的栈，这样在父节点进行切换左右子树的时候就可以通过这个栈把 next 处理好。当然，我们每次回溯的时候，因为当前节点有可能成为与当前节点的拥有最近公共祖先且深度相同的后继，所以回溯的时候要把当前节点重新进行入栈操作。所以在最左侧的右侧链跑完后，栈中还会存折这条链的每个节点。这部分可能比较抽象，不过思路挺妙的。 当然，空间复杂度仍不是最优解。

时间复杂度：$O(n)$，空间复杂度：$O(n)$。

DFS

根据法二的思路，我们发现，对于一个节点，能明确的是其父节点所在的层的链表是维护好的（当然，处理的顺序一定需要从右往左，这样左结点才可以用到右侧已维护好的结果），对于一个父节点，我们可以处理它的左右节点，具体流程：

1. 首先处理右孩子，我们通过父节点的 next 的链表可以找到右侧第一个拥有孩子节点的节点，这个节点的最左侧孩子节点 （也就是优先级左孩子大于右孩子）就是当前右孩子所在层次链表的后继；
2. 之后处理左孩子，与处理右孩子多出来的一步是先考虑父节点是否有右孩子，如果有就直接指向即可；
3. 处理完右孩子和左孩子之后就可以进行下一层的处理，当然这个顺序也可以是右孩子处理完马上处理其子树之后再处理左孩子，因为影响当前层处理的是其父节点的层，和其下一层没有关联；

时间复杂度：$O(n)$，空间复杂度：$O(1)$。

代码实现

DFS+栈

/*
// 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) {
        stack<Node*> rotate;
        while(!rotate.empty()) rotate.pop();
        dfs(rotate, _root);
        return _root;
    }
    
    void dfs(stack<Node*>& rotate, Node *_root) {
        if (_root == NULL) return ;
        if (!rotate.empty()) {
            _root->next = rotate.top();
            rotate.pop();
        }
        dfs(rotate, _root->right);
        dfs(rotate, _root->left);
        rotate.push(_root);
    }
};

DFS

/*
// 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 == NULL) return NULL;
        if (_root->right != NULL) {
            if (_root->next != NULL) {
                Node* cur = _root->next;
                while (cur != NULL && cur->left == NULL && cur->right == NULL) cur = cur->next; 
                if (cur != NULL) {
                    if (cur->left != NULL)
                        _root->right->next = cur->left;
                    else 
                        _root->right->next = cur->right;
                }
            }
            connect(_root->right);
        }
        if (_root->left != NULL) {
            if (_root->right != NULL) _root->left->next = _root->right;
            else if (_root->next != NULL) {
                Node* cur = _root->next;
                while (cur != NULL && cur->left == NULL && cur->right == NULL) cur = cur->next; 
                if (cur != NULL) {
                    if (cur->left != NULL)
                        _root->left->next = cur->left;
                    else 
                        _root->left->next = cur->right;
                }
            }
            connect(_root->left);
        }
        return _root;
    }
};