Merge branch 'develop'

# Conflicts:
#	SUMMARY.md
#	docs/jzof/of012.md

Author: Cori1109

docs/jzof/of007.md

@@ -0,0 +1,97 @@
+---
+description: 剑指 Offer 07. 重建二叉树
+---
+
+# OF6.重建二叉树
+
+## 题目描述
+
+[题目地址](https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/)
+
+输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
+
+
+### **示例 1：**
+
+```go
+前序遍历 preorder = [3,9,20,15,7]
+中序遍历 inorder = [9,3,15,20,7]
+
+3
+/ \
+9  20
+/  \
+15   7
+```
+
+## 题解
+
+### 思路1 ： 递归
+
+递归遍历
+
+**算法流程：**
+
+1. **复杂度分析：**
+2. **时间复杂度**$$O(N)$$**：**遍历N次，递归 N 次
+3. **空间复杂度**$$O(N)$$**：**递归 N 次，开辟 N 个栈空间
+
+#### 代码
+
+{% tabs %}
+{% tab title="Go" %}
+```go
+func reversePrint(head *ListNode) []int {
+    ans := make([]int, 0)
+    if head == nil {
+        return ans
+    }
+    ans = reversePrint(head.Next)
+    ans = append(ans, head.Val)
+    return ans
+}
+```
+{% endtab %}
+{% endtabs %}
+
+### 思路1 ： 多指针
+
+多个指针辅助，一次遍历
+
+**算法流程：**
+
+1. **复杂度分析：**
+2. **时间复杂度**$$O(N)$$**：**遍历N次，递归 N 次
+3. **空间复杂度**$$O(N)$$**：**递归 N 次，开辟 N 个栈空间
+
+#### 代码
+
+{% tabs %}
+{% tab title="Go" %}
+```go
+func reversePrint(head *ListNode) []int {
+    if head == nil {
+        return []int{}
+    }
+    pre, cur, next, ans := &ListNode{}, head, head.Next, []int{}
+    for cur != nil {
+        next = cur.Next
+        cur.Next = pre
+
+        pre = cur
+        cur = next
+    }
+    for pre.Next != nil {
+        ans = append(ans, pre.Val)
+        pre = pre.Next
+    }
+    return ans
+}
+```
+{% endtab %}
+{% endtabs %}
+
+## 总结
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 算法 题解：[awesome-golang-algorithm](https://github.com/kylesliu/awesome-golang-algorithm)
+

lcof/of000/Solution_test.go

@@ -43,7 +43,7 @@ func TestSolution(t *testing.T) {
 		for _, c := range cases {
 			t.Run(c.name, func(t *testing.T) {
 				actual := f(c.inputs)
-				ast.Equal(c.expect, actual,
+				ast.Equal(c, actual,
 					"func: %v case: %v ",
 					runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), c.name)
 			})

lcof/of012/Solution.go

@@ -5,16 +5,16 @@ func exist(board [][]byte, word string) bool {
 	for i := 0; i < m; i++ {
 		for j := 0; j < n; j++ {
 			//如果在数组中找得到第一个数，就执行下一步，否则返回false
-			if search(board, i, j, 0, word) {
+			if dfs(board, i, j, word) {
 				return true
 			}
 		}
 	}
 	return false
 }
-func search(board [][]byte, i, j, k int, word string) bool {
+func dfs(board [][]byte, i, j int, word string) bool {
 	//如果找到最后一个数，则返回true,搜索成功
-	if k == len(word) {
+	if len(word) == 0 {
 		return true
 	}
 	//i,j的约束条件
@@ -25,15 +25,15 @@ func search(board [][]byte, i, j, k int, word string) bool {
 	//进入DFS深度优先搜索
 	//先把正在遍历的该值重新赋值，如果在该值的周围都搜索不到目标字符，则再把该值还原
 	//如果在数组中找到第一个字符，则进入下一个字符的查找
-	if board[i][j] == word[k] {
+	if board[i][j] == word[0] {
 		temp := board[i][j]
 		board[i][j] = ' '
 		//下面这个if语句，如果成功进入，说明找到该字符，然后进行下一个字符的搜索,直到所有的搜索都成功，
 		//即k == len(word) - 1 的大小时，会返回true，进入该条件语句，然后返回函数true值。
-		if search(board, i, j+1, k+1, word) ||
-			search(board, i, j-1, k+1, word) ||
-			search(board, i+1, j, k+1, word) ||
-			search(board, i-1, j, k+1, word) {
+		if dfs(board, i, j+1, word[1:]) ||
+			dfs(board, i, j-1, word[1:]) ||
+			dfs(board, i+1, j, word[1:]) ||
+			dfs(board, i-1, j, word[1:]) {
 			return true
 		} else {
 			//没有找到目标字符，还原之前重新赋值的board[i][j]

lcof/of012/solution.py

@@ -1,13 +1,14 @@
 package Solution
 
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
+import (
+	"fmt"
+)
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
 
 func maxLevelSum(root *TreeNode) int {
 	tree := make(map[*TreeNode]int)
@@ -51,3 +52,27 @@ func maxLevelSum(root *TreeNode) int {
 	}
 	return l + 1
 }
+
+// DFS 递归的中序遍历
+func maxLevelSum2(root *TreeNode) int {
+	m, ans := make(map[int]int), -1
+	dfs(root, 1, m)
+	fmt.Println(m)
+	for _, v := range m {
+		if v > ans {
+			ans = v
+		}
+		print(v)
+	}
+	return ans
+}
+
+func dfs(root *TreeNode, level int, m map[int]int) {
+	if root == nil {
+		return
+	}
+	fmt.Println(level, root.Val)
+	dfs(root.Left, level+1, m)
+	m[level] += root.Val
+	dfs(root.Right, level+1, m)
+}

leetcode/1101-1200/1161.Maximum-Level-Sum-of-a-Binary-Tree/Solution.go

@@ -8,16 +8,11 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-type TreeNode struct {
-	Val   int
-	Left  *TreeNode
-	Right *TreeNode
-}
-
 type SolutionFuncType func(*TreeNode) int
 
 var SolutionFuncList = []SolutionFuncType{
-	maxLevelSum,
+	//maxLevelSum,
+	maxLevelSum2,
 }
 
 var DefaultValue int = -1024
@@ -58,15 +53,20 @@ func TestSolution(t *testing.T) {
 	ast := assert.New(t)
 
 	// The original Problem requires the binary tree constructed from array. Please refer to test cases produced at Leetcode problem https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/
-	treeNode := InitTree(1, 7, 0, 7, -8)
-
+	//treeNode := InitTree(1, 7, 0, 7, -8)
+	treeNode := &TreeNode{
+		Val:   1,
+		Left:  &TreeNode{Val: 7, Left: &TreeNode{Val: 7, Right: &TreeNode{Val: -8}}},
+		Right: &TreeNode{Val: 0},
+	}
 	var cases = []struct {
 		name   string
 		inputs *TreeNode
 		expect int
 	}{
 		{"TestCase1", treeNode, 2},
 	}
+	//ast.Equal(treeNode, &TreeNode{})
 	for _, f := range SolutionFuncList {
 		for _, c := range cases {
 			t.Run(c.name, func(t *testing.T) {