545. Boundary of Binary Tree

Given a binary tree, return the values of its boundary in anti-clockwise direction starting from root. Boundary includes left boundary, leaves, and right boundary in order without duplicate nodes. (The values of the nodes may still be duplicates.)

Left boundary is defined as the path from root to the left-most node. Right boundary is defined as the path from root to the right-most node. If the root doesn’t have left subtree or right subtree, then the root itself is left boundary or right boundary. Note this definition only applies to the input binary tree, and not applies to any subtrees.

The left-most node is defined as a leaf node you could reach when you always firstly travel to the left subtree if exists. If not, travel to the right subtree. Repeat until you reach a leaf node.

The right-most node is also defined by the same way with left and right exchanged.

Example 1

Input:
  1
   \
    2
   / \
  3   4

Ouput:
[1, 3, 4, 2]

Explanation:
The root doesn't have left subtree, so the root itself is left boundary.
The leaves are node 3 and 4.
The right boundary are node 1,2,4. Note the anti-clockwise direction means you should output reversed right boundary.
So order them in anti-clockwise without duplicates and we have [1,3,4,2].

Example 2

Input:
    ____1_____
   /          \
  2            3
 / \          / 
4   5        6   
   / \      / \
  7   8    9  10  
       
Ouput:
[1,2,4,7,8,9,10,6,3]

Explanation:

The left boundary are node 1,2,4. (4 is the left-most node according to definition)
The leaves are node 4,7,8,9,10.
The right boundary are node 1,3,6,10. (10 is the right-most node).
So order them in anti-clockwise without duplicate nodes we have [1,2,4,7,8,9,10,6,3].

方法1: recursion

思路：

这道题要返回的边界顺序是左边界，叶节点，右边界，不能够有重复。第一种方法用了三个递归函数，分别搜索这三个部分。函数中需要注意，这两个boundary不要包含叶子节点，否则会和搜叶子节点的函数产生重复。根节点单独处理比较好，如果存在，它会先于左边界被放进结果。然后对左紫薯递归调用leftBoundary，当root为空，或者为叶节点的时候，直接返回（这里要回避叶节点，避免重复）。不属于以上条件时，我们先把当前节点加入result，然后检查左右：如果左子树存在，递归到左边，不存在，递归到右边。这里两个事情需要注意：1. 只向一边调用，2. 先放结果再调用，相当于preorder。rightBoundary的顺序相反，先考虑向右边调用，如果右子树不存在向左边，并且要在调用结束后再打印当前节点，属于postorder。

易错点

1. 避免重复
2. 左右边界分别为pre/post order traversal

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> boundaryOfBinaryTree(TreeNode* root) {
        if (!root) return {};
        vector<int> result;
        if (root -> left || root -> right) result.push_back(root -> val);
        leftBoundary(root -> left, result);
        leaves(root, result);
        rightBoundary(root -> right, result);
        return result;
    }
    
    void leftBoundary(TreeNode* root, vector<int> & result) {
        if (!root || !root -> left && !root -> right) return;
        result.push_back(root -> val);
        if (!root -> left) leftBoundary(root -> right, result);
        else leftBoundary(root -> left, result);
    }
    
    void rightBoundary(TreeNode* root, vector<int> & result) {
        if (!root || !root -> left && !root -> right) return;
        if (!root -> right) rightBoundary(root -> left, result);
        else rightBoundary(root -> right, result);
        result.push_back(root -> val);
    }
    
    void leaves(TreeNode* root, vector<int> &result) {
        if (!root) return;
        if (!root -> left && !root -> right) {
            result.push_back(root -> val);
        }
        leaves(root -> left, result);
        leaves(root -> right, result);
    }
};

方法2: recursion

grandyang: https://www.cnblogs.com/grandyang/p/6833459.html
discussion: https://leetcode.com/problems/boundary-of-binary-tree/discuss/101294/Java-C%2B%2B-Clean-Code-(1-Pass-perorder-postorder-hybrid)

思路：

上面的三个函数可以被归并为同一个，用bool来标记左右。

class Solution {
public:
    vector<int> boundaryOfBinaryTree(TreeNode* root) {
        if (!root) return {};
        vector<int> res{root->val};
        helper(root->left, true, false, res);
        helper(root->right, false, true, res);
        return res;
    }
    void helper(TreeNode* node, bool leftbd, bool rightbd, vector<int>& res) {
        if (!node) return;
        if (!node->left && !node->right) {
            res.push_back(node->val);
            return;
        }
        if (leftbd) res.push_back(node->val);
        helper(node->left, leftbd && node->left, rightbd && !node->right, res);
        helper(node->right, leftbd && !node->left, rightbd && node->right, res);
        if (rightbd) res.push_back(node->val);
    }
};

二刷：

易错点：

1. 避免重复
2. 左右边界分别为pre/post order traversal
3. 如果root本身只有一个节点，需要避免所有位置的重复，包括左右边界和leaves函数。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> boundaryOfBinaryTree(TreeNode* root) {
        vector<int> res;
        if (!root) return res;
        res.push_back(root -> val);
        leftBoundary(root -> left, res);
        leaves(root -> left, res);
        leaves(root -> right, res);
        rightBoundary(root -> right, res);
        return res;
    }
    
    void leftBoundary(TreeNode* root, vector<int> & res){
        if (!root || !root -> left && !root -> right) return;
        res.push_back(root -> val);
        if (root -> left) leftBoundary(root -> left, res);
        else leftBoundary(root -> right, res);
        return;
    }
    void leaves(TreeNode* root, vector<int> & res) {
        if (!root) return;
        if (!root -> left && !root -> right) res.push_back(root -> val);
        leaves(root -> left, res);
        leaves(root -> right, res);
        return;
    }
    void rightBoundary(TreeNode* root, vector<int> & res) {
        if (!root || !root -> left && !root -> right) return;
        if (root -> right) rightBoundary(root -> right, res);
        else rightBoundary(root -> left, res);
        res.push_back(root -> val);
        return;
    }
};