solution to max-level-sum-binaryTree

Author: vortex-17

leetcode/1101-1200/1161.Maximum-Level-Sum-of-a-Binary-Tree/README.md

@@ -7,6 +7,7 @@
 Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.
 
 Return the smallest level X such that the sum of all the values of nodes at level X is maximal.
+
 **Example 1:**
 
 ```

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

@@ -8,11 +8,6 @@ package Solution
  *     Right *TreeNode
  * }
  */
-type TreeNode struct {
-	Val   int
-	Left  *TreeNode
-	Right *TreeNode
-}
 
 func maxLevelSum(root *TreeNode) int {
 	tree := make(map[*TreeNode]int)

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

@@ -2,8 +2,10 @@ package Solution
 
 import (
 	"reflect"
-	"strconv"
+	"runtime"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 type TreeNode struct {
@@ -12,77 +14,67 @@ type TreeNode struct {
 	Right *TreeNode
 }
 
-type BinaryTree struct {
-	root *TreeNode
-}
+type SolutionFuncType func(*TreeNode) int
 
-func (t *BinaryTree) insert(data int) *BinaryTree {
-	if t.root == nil {
-		t.root = &TreeNode{Val: data, Left: nil, Right: nil}
-	} else {
-		t.root.insert(data)
-	}
-	return t
+var SolutionFuncList = []SolutionFuncType{
+	maxLevelSum,
 }
 
-func (n *TreeNode) insert(data int) {
-	if n == nil {
+var DefaultValue int = -1024
+
+func InsertNodeToTree(tree *TreeNode, node *TreeNode) {
+	if tree == nil {
+		return
+	}
+	if tree.Val == DefaultValue {
+		tree.Val = node.Val
 		return
-	} else if data <= n.Val {
-		if n.Left == nil {
-			n.Left = &TreeNode{Val: data, Left: nil, Right: nil}
-		} else {
-			n.Left.insert(data)
+	}
+	if node.Val > tree.Val {
+		if tree.Right == nil {
+			tree.Right = &TreeNode{Val: DefaultValue}
 		}
-	} else {
-		if n.Right == nil {
-			n.Right = &TreeNode{Val: data, Left: nil, Right: nil}
-		} else {
-			n.Right.insert(data)
+		InsertNodeToTree(tree.Right, node)
+	}
+	if node.Val < tree.Val {
+		if tree.Left == nil {
+			tree.Left = &TreeNode{Val: DefaultValue}
 		}
+		InsertNodeToTree(tree.Left, node)
 	}
 }
 
-func main() {
-
+func InitTree(values ...int) (root *TreeNode) {
+	rootNode := TreeNode{Val: DefaultValue, Right: nil, Left: nil}
+	for _, value := range values {
+		node := TreeNode{Val: value}
+		InsertNodeToTree(&rootNode, &node)
+	}
+	return &rootNode
 }
 
 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/
-	tree1 := &BinaryTree{}
-	tree1.insert(1).
-		insert(7).
-		insert(0).
-		insert(7).
-		insert(-8)
+	treeNode := InitTree(1, 7, 0, 7, -8)
 
-	cases := []struct {
+	var cases = []struct {
 		name   string
-		inputs *BinaryTree
+		inputs *TreeNode
 		expect int
 	}{
-		{"TestCase1", tree1, 2},
+		{"TestCase1", treeNode, 2},
 	}
-
-	//	开始测试
-	for i, c := range cases {
-		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
-			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
-			}
-		})
+	for _, f := range SolutionFuncList {
+		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)
+			})
+		}
 	}
 }
-
-//	压力测试
-func BenchmarkSolution(b *testing.B) {
-
-}
-
-//	使用案列
-func ExampleSolution() {
-
-}