LeetCode - Populating Next Right Pointers in Each Node II

Populating Next Right Pointers in Each Node II

2014.1.8 21:00

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

Solution:

　　This problem is a variation from Populating Next Right Pointers in Each Node. The difference is that the tree needn't be perfect.

　　Solution is similar. The left node is next to the right node, and the right node is next to the leftest node right to it.

　　Time and space complexities are both O(n), where n is the number of nodes in the tree.

Accepted code:

// 1WA, 1AC, the first attempt is wrong, only works for perfect binary trees
/**
 * 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) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if(root == nullptr){
            return;
        }
        
        TreeLinkNode *pp;
        
        // search the next pointer from left to right
        pp = root->next;
        while(pp != nullptr){
            if(pp->left != nullptr){
                pp = pp->left;
                break;
            }
            if(pp->right != nullptr){
                pp = pp->right;
                break;
            }
            pp = pp->next;
        }
        
        if(root->right != nullptr){
            root->right->next = pp;
        }
        
        if(root->left != nullptr){
            root->left->next = (root->right != nullptr) ? root->right : pp;
        }
        
        // since the searching of next pointer is from left to right
        // the recursion must be done from right to left 
        connect(root->right);
        connect(root->left);
    }
};