Add first-common-ancestor-lcci

Author: beyondyyh

algorithms/README.md

@@ -53,6 +53,8 @@
 |0331|[验证二叉树的前序序列化](https://leetcode-cn.com/problems/verify-preorder-serialization-of-a-binary-tree/)|[go](./tree/331.isValidSerialization.go)|M|
 |0344|[反转字符串](https://leetcode-cn.com/problems/reverse-string/)|[go](./mystring/344.reverseString.go)|S|
 |0347|[前 K 个高频元素](https://leetcode-cn.com/problems/top-k-frequent-elements/)|[go](./myheap/347.topkFrequent.go)|M|
+|0404|[检查平衡性](https://leetcode-cn.com/problems/check-balance-lcci/)|[go](./tree/404.isBalanced.go)|S|
+|0408|[首个共同祖先](https://leetcode-cn.com/problems/first-common-ancestor-lcci/)|[go](./tree/408.lowestCommonAncestor.go)|M|
 |0412|[Fizz Buzz](https://leetcode-cn.com/problems/fizz-buzz/)|[go](./mystring/412.fizzBuzz.go)|S|
 |0442|[数组中重复的数据](https://leetcode-cn.com/problems/find-all-duplicates-in-an-array/)|[go](./myarray/442.findDuplicates.go)|M|
 |0468|[验证IP地址](https://leetcode-cn.com/problems/validate-ip-address/submissions/)|[go](./mystring/468.validIPAddress.go)|M|

algorithms/kit/Tcase.go

@@ -1,8 +1,17 @@
 package kit
 
+import (
+	"encoding/json"
+)
+
 // CaseEntry delcare
 type CaseEntry struct {
 	Name     string
 	Input    interface{}
 	Expected interface{}
 }
+
+func (c CaseEntry) String() string {
+	bc, _ := json.Marshal(c)
+	return string(bc)
+}

algorithms/kit/TreeNode.go

@@ -104,3 +104,17 @@ func Tree2Postorder(root *TreeNode) []int { // {{{
 	res = append(res, root.Val)
 	return res
 } // }}}
+
+// FindTargetNode 返回 Val = target 的 TreeNode
+// 假设root中一定有 node.Val = target
+func FindTargetNode(root *TreeNode, target int) *TreeNode {
+	if root == nil || root.Val == target {
+		return root
+	}
+
+	if res := FindTargetNode(root.Left, target); res != nil {
+		return res
+	}
+
+	return FindTargetNode(root.Right, target)
+}

algorithms/tree/404.isBalanced.go

@@ -0,0 +1,25 @@
+package tree
+
+import (
+	"math"
+)
+
+func isBalanced(root *TreeNode) bool {
+	if root == nil {
+		return true
+	}
+
+	if math.Abs(depth(root.Left)-depth(root.Right)) <= 1 {
+		return isBalanced(root.Left) && isBalanced(root.Right)
+	}
+
+	return false
+}
+
+func depth(root *TreeNode) float64 {
+	if root == nil {
+		return 0
+	}
+
+	return math.Max(depth(root.Left), depth(root.Right)) + 1
+}

algorithms/tree/404.isBalanced_test.go

@@ -0,0 +1,38 @@
+package tree
+
+import (
+	"testing"
+
+	"Leetcode/algorithms/kit"
+)
+
+// run: go test -v -run Test_isBalanced
+func Test_isBalanced(t *testing.T) {
+	cases := []kit.CaseEntry{
+		{
+			Name:     "x1",
+			Input:    []int{3, 9, 20, null, null, 15, 7, 1},
+			Expected: true,
+		},
+		{
+			Name:     "x2",
+			Input:    []int{1, 2, 2, 3, 3, null, null, 4, 4},
+			Expected: false,
+		},
+		{
+			Name:     "x3",
+			Input:    []int{},
+			Expected: true,
+		},
+		// add more test cases
+	}
+
+	for _, tt := range cases {
+		t.Run(tt.Name, func(t *testing.T) {
+			root := kit.Ints2Tree(tt.Input.([]int))
+			if output := isBalanced(root); output != tt.Expected.(bool) {
+				t.Errorf("isBalanced(%v)=%t, expected=%v", tt.Input, output, tt.Expected)
+			}
+		})
+	}
+}

algorithms/tree/408.lowestCommonAncestor.go

@@ -0,0 +1,17 @@
+package tree
+
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	if root == nil || root == p || root == q {
+		return root
+	}
+
+	left := lowestCommonAncestor(root.Left, p, q)
+	right := lowestCommonAncestor(root.Right, p, q)
+	if left != nil && right != nil {
+		return root
+	} else if left == nil {
+		return right
+	} else {
+		return left
+	}
+}

algorithms/tree/408.lowestCommonAncestor_test.go

@@ -0,0 +1,35 @@
+package tree
+
+import (
+	"testing"
+
+	"Leetcode/algorithms/kit"
+)
+
+// run: go test -v -run Test_lowestCommonAncestor
+func Test_lowestCommonAncestor(t *testing.T) {
+	cases := []kit.CaseEntry{
+		{
+			Name: "x1",
+			Input: map[string]interface{}{
+				"root": []int{3, 5, 1, 6, 2, 0, 8, null, null, 7, 4},
+				"p":    5,
+				"q":    1,
+			},
+			Expected: 3,
+		},
+	}
+
+	for _, tt := range cases {
+		t.Run(tt.Name, func(t *testing.T) {
+			input := tt.Input.(map[string]interface{})
+			root := kit.Ints2Tree(input["root"].([]int))
+			p := kit.FindTargetNode(root, input["p"].(int))
+			q := kit.FindTargetNode(root, input["q"].(int))
+			expected := kit.FindTargetNode(root, tt.Expected.(int))
+			if output := lowestCommonAncestor(root, p, q); output != expected {
+				t.Errorf("lowestCommonAncestor(%v, %d, %d)=%d, expected=%d", input["root"], p.Val, q.Val, output.Val, expected.Val)
+			}
+		})
+	}
+}