力扣每日一题2022-08-22中等题：输出二叉树

---

题目描述

输出二叉树

---

思路

DFS

首先使用深度优先搜索得到二叉树的高度height（本题中树的高度从0开始算，我不知道是不是我记错了我学习树的时候应该树的高度是从1开始计算的），然后创建一个行数为m=height+1列数为n=2^(height+1)-1的结果矩阵ans放置结点值。
根据题意，根结点应放在第一行正中间，根结点所在的行和列会将剩余空间划分为两部分（左下和右下），然后递归地将左子树和右子树分别输出在左下和右下两部分空间。

Python实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def printTree(self, root: Optional[TreeNode]) -> List[List[str]]:
        def getHeight(node):
            return max(getHeight(node.left)+1 if node.left else 0, getHeight(node.right)+1 if node.right else 0)
        height = getHeight(root)
        m = height+1
        n = 2 ** m - 1
        ans = [[""] * n for i in range(m)]
        def dfs(node, r, c):
            ans[r][c] = str(node.val)
            if node.left:
                dfs(node.left, r+1, c-2**(height-r-1))
            if node.right:
                dfs(node.right, r+1, c+2**(height-r-1))
        dfs(root, 0, (n-1)//2)
        return ans

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<String>> printTree(TreeNode root) {
        int height = getHeight(root);
        int m = height+1;
        int n = (1<<m) - 1;
        List<List<String>> ans = new ArrayList<List<String>>();
        for (int i = 0; i < m; i++) {
            List<String> row = new ArrayList<String>();
            for (int j = 0; j < n; j++) {
                row.add("");
            }
            ans.add(row);
        }
        dfs(ans, root, 0, (n-1)/2, height);
        return ans;
    }

    private int getHeight(TreeNode node) {
        int h = 0;
        if (node.left != null) {
            h = Math.max(h, getHeight(node.left)+1);
        }
        if (node.right != null) {
            h = Math.max(h, getHeight(node.right)+1);
        }
        return h;
    }

    private void dfs(List<List<String>> ans, TreeNode node, int r, int c, int height) {
        ans.get(r).set(c, Integer.toString(node.val));
        if (node.left != null) {
            dfs(ans, node.left, r+1, c-(1<<(height-r-1)), height);
        }
        if (node.right != null) {
            dfs(ans, node.right, r+1, c+(1<<(height-r-1)), height);
        }
    }
}

C++实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<string>> printTree(TreeNode* root) {
        int height = getHeight(root);
        int m = height + 1;
        int n = (1 << m) - 1;
        vector<vector<string>> ans(m, vector<string>(n, ""));
        dfs(ans, root, 0, (n-1)/2, height);
        return ans;
    }

    int getHeight(TreeNode* node) {
        int h = 0;
        if (node->left) {
            h = max(h, getHeight(node->left) + 1);
        }
        if (node->right) {
            h = max(h, getHeight(node->right) + 1);
        }
        return h;
    }

    void dfs(vector<vector<string>>& ans, TreeNode* node, int r, int c, int height) {
        ans[r][c] = to_string(node->val);
        if (node->left) {
            dfs(ans, node->left, r+1, c-(1<<(height-r-1)), height);
        }
        if (node->right) {
            dfs(ans, node->right, r+1, c+(1<<(height-r-1)), height);
        }
    }
};