[LeetCode] 545. Boundary of Binary Tree

The boundary of a binary tree is the concatenation of the root, the left boundary, the leaves ordered from left-to-right, and the reverse order of the right boundary.

The left boundary is the set of nodes defined by the following:

• The root node's left child is in the left boundary. If the root does not have a left child, then the left boundary is empty.
• If a node in the left boundary and has a left child, then the left child is in the left boundary.
• If a node is in the left boundary, has no left child, but has a right child, then the right child is in the left boundary.
• The leftmost leaf is not in the left boundary.

The right boundary is similar to the left boundary, except it is the right side of the root's right subtree. Again, the leaf is not part of the right boundary, and the right boundary is empty if the root does not have a right child.

The leaves are nodes that do not have any children. For this problem, the root is not a leaf.

Given the root of a binary tree, return the values of its boundary.

Example 1:

Input: root = [1,null,2,3,4]
Output: [1,3,4,2]
Explanation:
- The left boundary is empty because the root does not have a left child.
- The right boundary follows the path starting from the root's right child 2 -> 4.
  4 is a leaf, so the right boundary is [2].
- The leaves from left to right are [3,4].
Concatenating everything results in [1] + [] + [3,4] + [2] = [1,3,4,2].

Example 2:

Input: root = [1,2,3,4,5,6,null,null,null,7,8,9,10]
Output: [1,2,4,7,8,9,10,6,3]
Explanation:
- The left boundary follows the path starting from the root's left child 2 -> 4.
  4 is a leaf, so the left boundary is [2].
- The right boundary follows the path starting from the root's right child 3 -> 6 -> 10.
  10 is a leaf, so the right boundary is [3,6], and in reverse order is [6,3].
- The leaves from left to right are [4,7,8,9,10].
Concatenating everything results in [1] + [2] + [4,7,8,9,10] + [6,3] = [1,2,4,7,8,9,10,6,3]. 

Constraints:

• The number of nodes in the tree is in the range [1, 104].
• -1000 <= Node.val <= 1000

二叉树的边界。

题意是给一个二叉树，请按逆时针方向输出二叉树边界上的节点。这个题需要分成几个部分做，分别是 root 节点，左边缘的节点，叶子节点，右边缘的节点。

首先将根节点的值放入一个数组[1]，这没什么可说的；

再来是创建一个数组[2]，用先序遍历找到所有的左边缘的节点，注意不要将左子树上的叶子节点加入，判断方法是看当前节点是否有左右孩子，如果没有，则直接 return；

创建另一个数组[3]，用后序遍历找到所有右边缘的节点，注意不要将右子树上的叶子节点加入，判断方法是看当前节点是否有左右孩子，如果没有，则直接 return；

再创建一个数组[4]，存放所有的叶子节点，判断方法是如果当前节点没有左右孩子，则他本身就是个叶子节点。

最后拼接如上的几个数组 [1, 2, 3, 4]。

时间O(n)

空间O(h)

JavaScript实现

/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var boundaryOfBinaryTree = function (root) {
    var head = [];
    var left = [];
    var right = [];
    var leaves = [];
    var findLeft = function (root) {
        if (root) {
            // if it is a leaf node
            if (root.left === null && root.right === null) {
                return;
            }
            left.push(root.val);
            if (root.left) {
                findLeft(root.left);
            } else {
                findLeft(root.right);
            }
        }
    }

    var findRight = function (root) {
        if (root) {
            // if it is a leaf node
            if (root.left === null && root.right === null) {
                return;
            }
            if (root.right) {
                findRight(root.right);
            } else {
                findRight(root.left);
            }
            right.push(root.val);
        }
    };

    var findLeaves = function (root) {
        if (root) {
            if (root.left === null && root.right === null) {
                leaves.push(root.val);
            }
            findLeaves(root.left);
            findLeaves(root.right);
        }
    };

    var group = function (root) {
        if (root) {
            head.push(root.val);
            if (root.left) {
                findLeft(root.left);
            }
            if (root.right) {
                findRight(root.right);
            }
            if (root.left || root.right) {
                findLeaves(root);
            }
        }
    };
    group(root);
    return [...head, ...left, ...leaves, ...right];
};

Java实现

class Solution {
    List<Integer> res = new ArrayList<>();

    public List<Integer> boundaryOfBinaryTree(TreeNode root) {
        // corner case
        if (root == null) {
            return res;
        }

        // normal case
        res.add(root.val);
        leftBoundary(root.left);
        leaves(root.left);
        leaves(root.right);
        rightBoundary(root.right);
        return res;
    }

    // preorder
    private void leftBoundary(TreeNode root) {
        if (root == null || (root.left == null && root.right == null)) {
            return;
        }
        res.add(root.val);
        if (root.left == null) {
            leftBoundary(root.right);
        } else {
            leftBoundary(root.left);
        }
    }

    // postorder
    private void rightBoundary(TreeNode root) {
        if (root == null || (root.left == null && root.right == null)) {
            return;
        }
        if (root.right == null) {
            rightBoundary(root.left);
        } else {
            rightBoundary(root.right);
        }
        res.add(root.val);
    }

    private void leaves(TreeNode root) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            res.add(root.val);
            return;
        }
        leaves(root.left);
        leaves(root.right);
    }
}

相关题目

199. Binary Tree Right Side View

545. Boundary of Binary Tree

LeetCode 题目总结