Add: tree_node

internal/kit/tree_node.go

@@ -1,18 +1,64 @@
 package kit
 
+import "math"
+
+var NULL = math.MinInt32
+
 // Definition for a binary tree node.
 type TreeNode struct {
 Val int
 Left *TreeNode
 Right *TreeNode
 }
 
+// convert []int to *TreeNode
+func SliceInt2TreeNode(s []int) *TreeNode {
+l := len(s)
+if l == 0 {
+return nil
+}
+tree := &TreeNode{Val: s[0]}
+queue := make([]*TreeNode, 0)
+node := tree
+for i := 1; i < l; i++ {
+if s[i] != NULL {
+node.Left = &TreeNode{Val: s[i]}
+queue = append(queue, node.Left)
+}
+i++
+if i < l && s[i] != NULL {
+node.Right = &TreeNode{Val: s[i]}
+queue = append(queue, node.Right)
+}
+if len(queue) > 0 {
+node = queue[0]
+queue = queue[1:]
+} else {
+break
+}
+}
+return tree
+}
+
 // convert *TreeNode to []int
 func TreeNode2SliceInt(t *TreeNode) (s []int) {
+if t != nil {
+queue := make([]*TreeNode, 1)
+queue[0] = t
+for len(queue) > 0 {
+if queue[0] != nil {
+s = append(s, queue[0].Val)
+if queue[0].Left != nil || queue[0].Right != nil {
+queue = append(queue, queue[0].Left)
+}
+if queue[0].Right != nil {
+queue = append(queue, queue[0].Right)
+}
+} else {
+s = append(s, NULL)
+}
+queue = queue[1:]
+}
+}
 return
 }
-
-// convert []int to *TreeNode
-func SliceInt2TreeNode(s []int) *TreeNode {
-return nil
-}

internal/kit/tree_node_test.go

@@ -1,13 +1,36 @@
 package kit
 
-import "testing"
+import (
+"reflect"
+"testing"
+)
 
 func TestTreeNode(t *testing.T) {
-tests := [...][]int{
-{},
+tests := [...]struct {
+input []int
+expected []int
+}{
+{
+input: []int{1, 2, 3, 4},
+expected: []int{1, 2, 3, 4},
+},
+{
+input: []int{1, 2, 3, NULL, 5},
+expected: []int{1, 2, 3, NULL, 5},
+},
+{
+input: []int{1, 2, 3, NULL, 5, NULL, NULL, NULL},
+expected: []int{1, 2, 3, NULL, 5},
+},
+{
+input: nil,
+expected: nil,
+},
 }
-for _, input := range tests {
-TreeNode2SliceInt(nil)
-SliceInt2TreeNode(input)
+for _, tc := range tests {
+output := TreeNode2SliceInt(SliceInt2TreeNode(tc.input))
+if !reflect.DeepEqual(output, tc.expected) {
+t.Fatalf("input: %v, output: %v, expected: %v", tc.input, output, tc.expected)
+}
 }
 }

problems/construct-string-from-binary-tree/construct_string_from_binary_tree.go

@@ -1 +1,15 @@
 package construct_string_from_binary_tree
+
+import . "github.com/openset/leetcode/internal/kit"
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ * Val int
+ * Left *TreeNode
+ * Right *TreeNode
+ * }
+ */
+func tree2str(t *TreeNode) string {
+return ""
+}

problems/construct-string-from-binary-tree/construct_string_from_binary_tree_test.go

@@ -1 +1,31 @@
 package construct_string_from_binary_tree
+
+import (
+"testing"
+
+. "github.com/openset/leetcode/internal/kit"
+)
+
+type caseType struct {
+input []int
+expected string
+}
+
+func TestTree2str(t *testing.T) {
+tests := [...]caseType{
+{
+input: []int{1, 2, 3, 4},
+expected: "",
+},
+{
+input: []int{1, 2, 3, NULL, 4},
+expected: "",
+},
+}
+for _, tc := range tests {
+output := tree2str(SliceInt2TreeNode(tc.input))
+if output != tc.expected {
+t.Fatalf("input: %v, output: %v, expected: %v", tc.input, output, tc.expected)
+}
+}
+}