feat: 2021年05月12日18:59:59

陈世伟 · 陈世伟 · commit 41af90b960ac · 2021-05-12T19:00:04.000+08:00
diff --git a/leetcode/105.从前序与中序遍历序列构造二叉树/build_tree.go b/leetcode/105.从前序与中序遍历序列构造二叉树/build_tree.go
@@ -1,4 +1,4 @@
-package _105
+package _05_从前序与中序遍历序列构造二叉树
 
 /**
  * Definition for a binary tree node.
@@ -23,25 +23,33 @@ func buildTree(preorder []int, inorder []int) *TreeNode {
 		return nil
 	}
 
+	rootVal := preorder[0]
 	rootNode := &TreeNode{
-		Val:   preorder[0],
+		Val:   rootVal,
 		Left:  nil,
 		Right: nil,
 	}
+	preorder = preorder[1:]
 
 	// 找到根节点在中序遍历的位置
 	// 根据中序遍历的特性 root节点左边的都是root节点的左子树，数量为(rootIndex+1)
 	var rootIndex int
 
 	for i, v := range inorder {
-		if v == preorder[0] {
+		if v == rootVal {
 			rootIndex = i
 			break
 		}
 	}
 
+	leftInorder := inorder[:rootIndex]
+	rightInorder := inorder[rootIndex+1:]
+
+	leftPreorder := preorder[:len(leftInorder)]
+	rightPreorder := preorder[len(leftInorder):]
+
 	// 前序遍历的根节点的后面是左子树，左子树的切片为(1:rootIndex+1)
-	rootNode.Left = buildTree(preorder[1:rootIndex+1], inorder[:rootIndex])
-	rootNode.Right = buildTree(preorder[rootIndex+1:], inorder[rootIndex+1:])
+	rootNode.Left = buildTree(leftPreorder, leftInorder)
+	rootNode.Right = buildTree(rightPreorder, rightInorder)
 	return rootNode
 }
diff --git a/leetcode/105.从前序与中序遍历序列构造二叉树/build_tree_test.go b/leetcode/105.从前序与中序遍历序列构造二叉树/build_tree_test.go
@@ -1,4 +1,4 @@
-package _105
+package _05_从前序与中序遍历序列构造二叉树
 
 import (
 	"reflect"
@@ -45,7 +45,7 @@ func Test_buildTree(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := buildTree(tt.args.preorder, tt.args.inorder); !reflect.DeepEqual(got, tt.want) {
+			if got := buildTree1(tt.args.preorder, tt.args.inorder); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("buildTree() = %v, want %v", got, tt.want)
 			}
 		})
diff --git a/leetcode/106.从中序与后序遍历序列构造二叉树/buildTree.go b/leetcode/106.从中序与后序遍历序列构造二叉树/buildTree.go
@@ -0,0 +1,45 @@
+package _06_从中序与后序遍历序列构造二叉树
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func buildTree(inorder []int, postorder []int) *TreeNode {
+	if len(postorder) == 0 {
+		return nil
+	}
+	// 从后序遍历获取root
+	rootVal := postorder[len(postorder)-1]
+	root := &TreeNode{
+		Val: rootVal,
+	}
+	if len(postorder) == 1 {
+		return root
+	}
+	// 从后序遍历删除root
+	postorder = postorder[:len(postorder)-1]
+
+	// 获取root在中序遍历的位置
+	var rootIdx int
+	for i := 0; i < len(inorder); i++ {
+		if inorder[i] == rootVal {
+			rootIdx = i
+			break
+		}
+	}
+
+	// root在中序遍历的位置切分左右子树，后续根据前序切分的数组长度切分后续数组
+	root.Left = buildTree(inorder[:rootIdx], postorder[:len(inorder[:rootIdx])])
+	root.Right = buildTree(inorder[rootIdx+1:], postorder[len(inorder[:rootIdx]):])
+	return root
+}
diff --git a/leetcode/106.从中序与后序遍历序列构造二叉树/buildTree_test.go b/leetcode/106.从中序与后序遍历序列构造二叉树/buildTree_test.go
@@ -0,0 +1,46 @@
+package _06_从中序与后序遍历序列构造二叉树
+
+import (
+	"log"
+	"reflect"
+	"testing"
+)
+
+func Test_buildTree(t *testing.T) {
+	type args struct {
+		inorder   []int
+		postorder []int
+	}
+	tests := []struct {
+		name string
+		args args
+		want *TreeNode
+	}{
+		{name: `中序遍历 inorder = [9,3,15,20,7]
+后序遍历 postorder = [9,15,7,20,3]`, args: struct {
+			inorder   []int
+			postorder []int
+		}{inorder: []int{9, 3, 15, 20, 7}, postorder: []int{9, 15, 7, 20, 3}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := buildTree(tt.args.inorder, tt.args.postorder)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("buildTree() = %v, want %v", got, tt.want)
+			}
+
+			InEach(got)
+		})
+	}
+}
+
+func InEach(root *TreeNode) {
+	if root == nil {
+		return
+	}
+	InEach(root.Left)
+	log.Println(root.Val)
+	InEach(root.Right)
+
+	return
+}
diff --git a/leetcode/112.路径总和/hasPathSum.go b/leetcode/112.路径总和/hasPathSum.go
@@ -0,0 +1,32 @@
+package _12_路径总和
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func hasPathSum(root *TreeNode, targetSum int) bool {
+	if root == nil {
+		return false
+	}
+
+	if isLeafNode(root) && root.Val == targetSum {
+		return true
+	}
+
+	return hasPathSum(root.Left, targetSum-root.Val) || hasPathSum(root.Right, targetSum-root.Val)
+}
+
+func isLeafNode(node *TreeNode) bool {
+	return node != nil && node.Left == nil && node.Right == nil
+}
diff --git a/leetcode/112.路径总和/hasPathSum_test.go b/leetcode/112.路径总和/hasPathSum_test.go
@@ -0,0 +1,40 @@
+package _12_路径总和
+
+import "testing"
+
+func Test_hasPathSum(t *testing.T) {
+	type args struct {
+		root      *TreeNode
+		targetSum int
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{name: `输入：root = [1,2,3], targetSum = 5
+输出：false`, args: args{
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   2,
+					Left:  nil,
+					Right: nil,
+				},
+				Right: &TreeNode{
+					Val:   3,
+					Left:  nil,
+					Right: nil,
+				},
+			},
+			targetSum: 5,
+		}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := hasPathSum(tt.args.root, tt.args.targetSum); got != tt.want {
+				t.Errorf("hasPathSum() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/leetcode/113.路径总和II/pathSum.go b/leetcode/113.路径总和II/pathSum.go
@@ -0,0 +1,52 @@
+package _13_路径总和II
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func pathSum(root *TreeNode, targetSum int) [][]int {
+	if root == nil {
+		return nil
+	}
+
+	var result [][]int
+
+	var each func(node *TreeNode, targetSum int, nums []int)
+
+	each = func(node *TreeNode, targetSum int, nums []int) {
+		if node == nil {
+			return
+		}
+
+		newSums := make([]int, len(nums), cap(nums))
+		copy(newSums, nums)
+
+		if IsLeafNode(node) && targetSum == node.Val {
+			result = append(result, append(newSums, node.Val))
+			return
+		}
+
+		each(node.Left, targetSum-node.Val, append(newSums, node.Val))
+		each(node.Right, targetSum-node.Val, append(newSums, node.Val))
+	}
+	each(root, targetSum, []int{})
+
+	return result
+}
+
+func IsLeafNode(node *TreeNode) bool {
+	if node == nil {
+		return false
+	}
+	return node.Left == nil && node.Right == nil
+}
diff --git a/leetcode/113.路径总和II/pathSum_test.go b/leetcode/113.路径总和II/pathSum_test.go
@@ -0,0 +1,88 @@
+package _13_路径总和II
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_pathSum(t *testing.T) {
+	type args struct {
+		root      *TreeNode
+		targetSum int
+	}
+	tests := []struct {
+		name string
+		args args
+		want [][]int
+	}{
+		{name: `输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
+输出：[[5,4,11,2],[5,8,4,5]]`, args: args{
+			root: &TreeNode{
+				Val: 5,
+				Left: &TreeNode{
+					Val: 4,
+					Left: &TreeNode{
+						Val: 11,
+						Left: &TreeNode{
+							Val:   7,
+							Left:  nil,
+							Right: nil,
+						},
+						Right: &TreeNode{
+							Val:   2,
+							Left:  nil,
+							Right: nil,
+						},
+					},
+					Right: nil,
+				},
+				Right: &TreeNode{
+					Val: 8,
+					Left: &TreeNode{
+						Val:   13,
+						Left:  nil,
+						Right: nil,
+					},
+					Right: &TreeNode{
+						Val: 4,
+						Left: &TreeNode{
+							Val:   5,
+							Left:  nil,
+							Right: nil,
+						},
+						Right: &TreeNode{
+							Val:   1,
+							Left:  nil,
+							Right: nil,
+						},
+					},
+				},
+			},
+			targetSum: 22,
+		}, want: [][]int{{5, 4, 11, 2}, {5, 8, 4, 5}}},
+		{name: `输入：root = [1,2,3], targetSum = 5
+输出：[]`, args: args{
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   2,
+					Left:  nil,
+					Right: nil,
+				},
+				Right: &TreeNode{
+					Val:   3,
+					Left:  nil,
+					Right: nil,
+				},
+			},
+			targetSum: 5,
+		}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := pathSum(tt.args.root, tt.args.targetSum); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("pathSum() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/leetcode/404.左叶子之和/sumOfLeftLeaves.go b/leetcode/404.左叶子之和/sumOfLeftLeaves.go
@@ -0,0 +1,30 @@
+package _04_左叶子之和
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func sumOfLeftLeaves(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	left := sumOfLeftLeaves(root.Left)
+	right := sumOfLeftLeaves(root.Right)
+	// 是否是有效的左叶子节点
+	var mid int
+	if root.Left != nil && root.Left.Left == nil && root.Left.Right == nil {
+		mid = root.Left.Val
+	}
+
+	return mid + left + right
+}
diff --git a/leetcode/513.找树左下角的值/findBottomLeftValue.go b/leetcode/513.找树左下角的值/findBottomLeftValue.go
diff --git a/leetcode/513.找树左下角的值/findBottomLeftValue_test.go b/leetcode/513.找树左下角的值/findBottomLeftValue_test.go

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package _105`
	`1`	`+package _05_从前序与中序遍历序列构造二叉树`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"reflect"`
`@@ -45,7 +45,7 @@ func Test_buildTree(t *testing.T) {`
`45`	`45`	`}`
`46`	`46`	`for _, tt := range tests {`
`47`	`47`	`t.Run(tt.name, func(t *testing.T) {`
`48`		`- if got := buildTree(tt.args.preorder, tt.args.inorder); !reflect.DeepEqual(got, tt.want) {`
	`48`	`+ if got := buildTree1(tt.args.preorder, tt.args.inorder); !reflect.DeepEqual(got, tt.want) {`
`49`	`49`	`t.Errorf("buildTree() = %v, want %v", got, tt.want)`
`50`	`50`	`}`
`51`	`51`	`})`