[LeetCode]Populating Next Right Pointers in Each Node II

Populating Next Right Pointers in Each Node II

Follow up for problem "Populating Next Right Pointers in Each Node".

What if the given tree could be any binary tree? Would your previous solution still work?

Note:

• You may only use constant extra space.

For example,
Given the following binary tree,

         1
       /  
      2    3
     /     
    4   5    7

After calling your function, the tree should look like:

         1 -> NULL
       /  
      2 -> 3 -> NULL
     /     
    4-> 5 -> 7 -> NULL

借鉴上一篇的方法，先找到下一行的第一个节点，然后把一整行处理完毕。
违规了，用到了额外的空间，但是很好理解。
这里用到的额外的空间vector<TreeLinkNode*>nodes 保存下一行找到的所有节点。
第一个节点就是下次行遍历的起点。

/**
 * Definition for binary tree with next pointer.
 * struct TreeLinkNode {
 *  int val;
 *  TreeLinkNode *left, *right, *next;
 *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
 * };
 */
class Solution {
public:
    void connect(TreeLinkNode *root) {
        if(!root) return;
        vector<TreeLinkNode*> nodes;
        while(root)
        {
            if(root->left) nodes.push_back(root->left);
            if(root->right) nodes.push_back(root->right);
            root = root->next;
        }
        if(nodes.size()==0)
        {
            root = NULL;
        }
        else
        {
            root = nodes[0];
            if(nodes.size()>1)
            {
                for(int i=1;i<nodes.size();i++)
                {
                    nodes[i-1]->next = nodes[i];
                }
            }
        }
        connect(root);
    }
};

那么，我们可不可以不违规，只用O(1)的空间呢？
答案是肯定的。
我们知道记住扫描下一行时，第一个出现的就可以了。
是不是很简单呢。。。和上面的原理一模一样，理解起来麻烦一点而已，不过，上面的你理解了，这个理解起来还是很简单的。

/**
 * Definition for binary tree with next pointer.
 * struct TreeLinkNode {
 *  int val;
 *  TreeLinkNode *left, *right, *next;
 *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
 * };
 */
class Solution {
public:
    void connect(TreeLinkNode *root) {
        if(!root) return;
        TreeLinkNode* first_node ;
        TreeLinkNode* pre_node ;
        TreeLinkNode* next_node ;
        int i=0;
        while(root)
        {
            if(root->left)
            {
                i++;
                if(i==1)
                {
                    first_node = root->left;
                    pre_node = root->left;
                }
                else
                {
                    next_node = root->left;
                    pre_node->next = next_node;
                    pre_node = next_node;
                }
            }
            if(root->right)
            {
                i++;
                if(i==1)
                {
                    first_node = root->right;
                    pre_node = root->right;
                }
                else
                {
                    next_node = root->right;
                    pre_node->next = next_node;
                    pre_node = next_node;
                }
            }
            root = root->next;
        }
        if(i==0) connect(NULL);
        else connect(first_node);
    }
};