add some tree solution

Author: Cori1109

lcof/of042/README.md

@@ -1,16 +1,57 @@
 package Solution
 
-func maxSubArray(nums []int) int {
+// 动态规划1
+func maxSubArray_1(nums []int) int {
+	if len(nums) == 1 {
+		return nums[0]
+	}
+	dp := make([]int, len(nums))
+	dp[0] = nums[0]
+	ans := dp[0]
+	for i := 1; i < len(nums); i++ {
+		dp[i] = max(dp[i-1]+nums[i], nums[i])
+		ans = max(ans, dp[i])
+	}
+	return ans
+}
+
+// 动态规划2
+func maxSubArray_2(nums []int) int {
 	ans := nums[0]
 	for i := 1; i < len(nums); i++ {
-		if nums[i-1] > 0 {
-			nums[i] += nums[i-1]
-		}
+		nums[i] = max(nums[i-1]+nums[i], nums[i])
 		ans = max(ans, nums[i])
 	}
 	return ans
 }
 
+// 分治
+func maxSubArray_3(nums []int) int {
+	return get(nums, 0, len(nums)-1).mSum
+}
+
+func pushUp(l, r Status) Status {
+	iSum := l.iSum + r.iSum
+	lSum := max(l.lSum, l.iSum+r.lSum)
+	rSum := max(r.rSum, r.iSum+l.rSum)
+	mSum := max(max(l.mSum, r.mSum), l.rSum+r.lSum)
+	return Status{lSum, rSum, mSum, iSum}
+}
+
+func get(nums []int, l, r int) Status {
+	if l == r {
+		return Status{nums[l], nums[l], nums[l], nums[l]}
+	}
+	m := (l + r) >> 1
+	lSub := get(nums, l, m)
+	rSub := get(nums, m+1, r)
+	return pushUp(lSub, rSub)
+}
+
+type Status struct {
+	lSum, rSum, mSum, iSum int
+}
+
 func max(x, y int) int {
 	if x > y {
 		return x

lcof/of042/Solution.go

@@ -1,8 +1,10 @@
 package Solution
 
 import (
+	"fmt"
 	"reflect"
 	"runtime"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -12,10 +14,12 @@ import (
 type SolutionFuncType func([]int) int
 
 var SolutionFuncList = []SolutionFuncType{
-	maxSubArray,
+	maxSubArray_1,
+	maxSubArray_2,
+	maxSubArray_3,
 }
 
-//	test info struct
+//	Test info struct
 type Case struct {
 	name   string
 	inputs []int
@@ -24,24 +28,23 @@ type Case struct {
 
 // 	test case
 var cases = []Case{
-	{
-		name:   "TestCase 1",
-		inputs: []int{-2, 1, -3, 4, -1, 2, 1, -5, 4},
-		expect: 6,
-	},
+	{name: "TestCase 1", inputs: []int{1}, expect: 1},
+	{name: "TestCase 2", inputs: []int{-2, 1}, expect: 1},
+	{name: "TestCase 3", inputs: []int{-2, -1}, expect: -1},
+	{name: "TestCase 4", inputs: []int{-2, 1, -3, 4, -1, 2, 1, -5, 4}, expect: 6},
 }
 
 // TestSolution Example for solution test cases
 func TestSolution(t *testing.T) {
 	ast := assert.New(t)
 
 	for _, f := range SolutionFuncList {
+		funcName := strings.Split(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), ".")[1]
 		for _, c := range cases {
-			t.Run(c.name, func(t *testing.T) {
-				actual := f(c.inputs)
-				ast.Equal(c.expect, actual,
-					"func: %v case: %v ",
-					runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), c.name)
+			t.Run(fmt.Sprintf("%s %s", funcName, c.name), func(t *testing.T) {
+				got := f(c.inputs)
+				ast.Equal(c.expect, got,
+					"func: %v case: %v ", funcName, c.name)
 			})
 		}
 	}

lcof/of042/Solution_test.go

@@ -0,0 +1,49 @@
+package Solution
+
+import (
+	"sort"
+)
+
+func missingNumber_1(nums []int) int {
+	sort.Ints(nums)
+	if nums[0] != 0 {
+		return 0
+	} else if nums[len(nums)-1] != len(nums) {
+		return len(nums)
+	}
+	for i := 1; i < len(nums); i++ {
+		if i != nums[i] {
+			return i
+		}
+	}
+	return 0
+}
+
+func missingNumber_2(nums []int) int {
+	m := make(map[int]int)
+	for _, v := range nums {
+		m[v]++
+	}
+	for i := range nums {
+		if _, ok := m[i+1]; !ok {
+			return i + 1
+		}
+	}
+	return 0
+}
+
+func missingNumber_3(nums []int) int {
+	ans := len(nums)
+	for i, v := range nums {
+		ans ^= i ^ v
+	}
+	return ans
+}
+
+func missingNumber_4(nums []int) int {
+	sum := len(nums) * (len(nums) + 1) / 2
+	for _, v := range nums {
+		sum -= v
+	}
+	return sum
+}

lcof/of053-II/Solution.go

@@ -0,0 +1,55 @@
+package Solution
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// Solution func Info
+type SolutionFuncType func([]int) int
+
+var SolutionFuncList = []SolutionFuncType{
+	missingNumber_1,
+	missingNumber_2,
+	missingNumber_3,
+	missingNumber_4,
+}
+
+// Test case info struct
+type Case struct {
+	name   string
+	input  []int
+	expect int
+}
+
+// Test case
+var cases = []Case{
+	{"TestCase 1", []int{3, 0, 1}, 2},
+	{"TestCase 2", []int{9, 6, 4, 2, 3, 5, 7, 0, 1}, 8},
+	{"TestCase 2", []int{0, 1}, 2},
+}
+
+// TestSolution Run test case for all solutions
+func TestSolution(t *testing.T) {
+	ast := assert.New(t)
+
+	for _, f := range SolutionFuncList {
+		funcName := strings.Split(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), ".")[1]
+		for _, c := range cases {
+			t.Run(fmt.Sprintf("%s %s", funcName, c.name), func(t *testing.T) {
+				nums := make([]int, 0)
+				for _, v := range c.input {
+					nums = append(nums, v)
+				}
+				got := f(nums)
+				ast.Equal(c.expect, got,
+					"func: %v case: %v ", funcName, c.name)
+			})
+		}
+	}
+}

lcof/of053-II/Solution_test.go

@@ -10,22 +10,24 @@ type TreeNode struct {
 	Right *TreeNode
 }
 
-func kthLargest(root *TreeNode, k int) int {
-	var nums []int
-	nums = dfs(&nums, root)
-	return nums[k-1]
-}
+func kthLargest_1(root *TreeNode, k int) int {
+	ans := -1
+	var dfs func(node *TreeNode)
+	dfs = func(node *TreeNode) {
+		if node == nil {
+			return
+		}
+		dfs(node.Right)
+		if k == 0 {
+			return
+		}
+		k--
+		if k == 0 {
+			ans = node.Val
+		}
+		dfs(node.Left)
 
-// 逆中序遍历（右中左 -- 递减序列）
-func dfs(nums *[]int, r *TreeNode) []int {
-	if r.Right != nil {
-		dfs(nums, r.Right)
-	}
-	if r != nil {
-		*nums = append(*nums, r.Val)
-	}
-	if r.Left != nil {
-		dfs(nums, r.Left)
 	}
-	return *nums
+	dfs(root)
+	return ans
 }

lcof/of054/README.md

@@ -12,7 +12,7 @@ import (
 type SolutionFuncType func(*TreeNode, int) int
 
 var SolutionFuncList = []SolutionFuncType{
-	kthLargest,
+	kthLargest_1,
 }
 
 //	test info struct

lcof/of054/Solution.go

@@ -6,27 +6,28 @@ type TreeNode struct {
 	Right *TreeNode
 }
 
-func inorderTraversal(root *TreeNode) []int {
+func inorderTraversal_1(root *TreeNode) []int {
 	ans := make([]int, 0)
 	if root != nil {
-		ans = append(ans, inorderTraversal(root.Left)...)
+		ans = append(ans, inorderTraversal_1(root.Left)...)
 		ans = append(ans, root.Val)
-		ans = append(ans, inorderTraversal(root.Right)...)
+		ans = append(ans, inorderTraversal_1(root.Right)...)
 	}
 	return ans
 }
 
 func inorderTraversal_2(root *TreeNode) []int {
-	ans, stack := make([]int, 0), []*TreeNode{}
-	for root != nil || len(stack) > 0 {
-		for root != nil {
-			stack = append(stack, root)
-			root = root.Left
+	ans, stk := make([]int, 0), []*TreeNode{}
+	node := root
+	for node != nil || len(stk) > 0 {
+		for node != nil {
+			stk = append(stk, node)
+			node = node.Left
 		}
-		root = stack[len(stack)-1]
-		stack = stack[:len(stack)-1]
-		ans = append(ans, root.Val)
-		root = root.Right
+		node = stk[len(stk)-1]
+		stk = stk[:len(stk)-1]
+		ans = append(ans, node.Val)
+		node = node.Right
 	}
 	return ans
 }