feat: add solutions to lc problem: No.0655

No.0655.Print Binary Tree

Author: yanglbme

solution/0600-0699/0655.Print Binary Tree/README.md

@@ -67,22 +67,186 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+> 中文题意不容易读懂，可以参考[英文版本的题目描述](/solution/0600-0699/0655.Print%20Binary%20Tree/README_EN.md)。
+
+先求二叉树的高度 h，然后根据 h 求得结果列表的行数和列数 m, n。
+
+根据 m, n 初始化结果列表，然后 dfs 遍历二叉树，依次在每个位置填入二叉树节点值（字符串形式）即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```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: TreeNode) -> List[List[str]]:
+        def height(root):
+            if root is None:
+                return -1
+            return 1 + max(height(root.left), height(root.right))
+
+        def dfs(root, r, c):
+            if root is None:
+                return
+            ans[r][c] = str(root.val)
+            dfs(root.left, r + 1, c - 2 ** (h - r - 1))
+            dfs(root.right, r + 1, c + 2 ** (h - r - 1))
 
+        h = height(root)
+        m, n = h + 1, 2 ** (h + 1) - 1
+        ans = [[""] * n for _ in range(m)]
+        dfs(root, 0, (n - 1) // 2)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```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 h = height(root);
+        int m = h + 1, n = (1 << (h + 1)) - 1;
+        String[][] res = new String[m][n];
+        for (int i = 0; i < m; ++i) {
+            Arrays.fill(res[i], "");
+        }
+        dfs(root, res, h, 0, (n - 1) / 2);
+        List<List<String>> ans = new ArrayList<>();
+        for (String[] t : res) {
+            ans.add(Arrays.asList(t));
+        }
+        return ans;
+    }
+
+    private void dfs(TreeNode root, String[][] res, int h, int r, int c) {
+        if (root == null) {
+            return;
+        }
+        res[r][c] = String.valueOf(root.val);
+        dfs(root.left, res, h, r + 1, c - (1 << (h - r - 1)));
+        dfs(root.right, res, h, r + 1, c + (1 << (h - r - 1)));
+    }
+
+    private int height(TreeNode root) {
+        if (root == null) {
+            return -1;
+        }
+        return 1 + Math.max(height(root.left), height(root.right));
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/**
+ * 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 h = height(root);
+        int m = h + 1, n = (1 << (h + 1)) - 1;
+        vector<vector<string>> ans(m, vector<string>(n, ""));
+        dfs(root, ans, h, 0, (n - 1) / 2);
+        return ans;
+    }
+
+    void dfs(TreeNode* root, vector<vector<string>>& ans, int h, int r, int c) {
+        if (!root) return;
+        ans[r][c] = to_string(root->val);
+        dfs(root->left, ans, h, r + 1, c - pow(2, h - r - 1));
+        dfs(root->right, ans, h, r + 1, c + pow(2, h - r - 1));
+    }
+
+    int height(TreeNode* root) {
+        if (!root) return -1;
+        return 1 + max(height(root->left), height(root->right));
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func printTree(root *TreeNode) [][]string {
+	var height func(root *TreeNode) int
+	height = func(root *TreeNode) int {
+		if root == nil {
+			return -1
+		}
+		return 1 + max(height(root.Left), height(root.Right))
+	}
+	h := height(root)
+	m, n := h+1, (1<<(h+1))-1
+	ans := make([][]string, m)
+	for i := range ans {
+		ans[i] = make([]string, n)
+		for j := range ans[i] {
+			ans[i][j] = ""
+		}
+	}
+	var dfs func(root *TreeNode, r, c int)
+	dfs = func(root *TreeNode, r, c int) {
+		if root == nil {
+			return
+		}
+		ans[r][c] = strconv.Itoa(root.Val)
+		dfs(root.Left, r+1, c-int(math.Pow(float64(2), float64(h-r-1))))
+		dfs(root.Right, r+1, c+int(math.Pow(float64(2), float64(h-r-1))))
+	}
+
+	dfs(root, 0, (n-1)/2)
+	return ans
+}
 
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**