add solution construct-binary-search-tree-from-preorder-traversal

Author: freefcw

go/construct-binary-search-tree-from-preorder-traversal.go

@@ -0,0 +1,36 @@
+package leetcode
+
+// https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/
+
+func addBinaryTreeNode(root *TreeNode, val int) {
+	if val < root.Val {
+		if root.Left == nil {
+			node := new(TreeNode)
+			node.Val = val
+			root.Left = node
+		} else {
+			addBinaryTreeNode(root.Left, val)
+		}
+		return
+	}
+	if root.Right == nil {
+		node := new(TreeNode)
+		node.Val = val
+		root.Right = node
+	} else {
+		addBinaryTreeNode(root.Right, val)
+	}
+}
+
+func bstFromPreorder(preorder []int) *TreeNode {
+	if len(preorder) == 0 {
+		return nil
+	}
+	root := new(TreeNode)
+	root.Val = preorder[0]
+	for i := 1; i < len(preorder); i++ {
+		addBinaryTreeNode(root, preorder[i])
+	}
+
+	return root
+}

go/construct-binary-search-tree-from-preorder-traversal_test.go

@@ -0,0 +1,32 @@
+package leetcode
+
+import "testing"
+
+func TestBstFromPreorder(t *testing.T) {
+	tests := []struct {
+		preorder []int
+		expect   []int
+	}{
+		{
+			preorder: []int{8, 5, 1, 7, 10, 12},
+			expect:   []int{8, 5, 10, 1, 7, -1, 12},
+		}, {
+			preorder: []int{},
+			expect:   []int{},
+		}, {
+			preorder: []int{8},
+			expect:   []int{8},
+		}, {
+			preorder: []int{8, 2, 9},
+			expect:   []int{8, 2, 9},
+		},
+	}
+
+	for i, item := range tests {
+		actual := bstFromPreorder(item.preorder)
+		actualData := treeToSlice(actual, -1)
+		if !intsEqual(actualData, item.expect) {
+			t.Errorf("%d expect %v, actual %v", i, item.expect, actualData)
+		}
+	}
+}

go/tree-node.go

@@ -7,6 +7,47 @@ type TreeNode struct {
 	Right *TreeNode
 }
 
+func treeToSlice(root *TreeNode, d int) []int {
+	if root == nil {
+		return make([]int, 0)
+	}
+	nodes := make([]*TreeNode, 64)
+	vals := make([]int, 64)
+	nodes[0] = root
+	index := 0
+	nodeMax := 0
+	for {
+		if index > nodeMax {
+			break
+		}
+		if nodes[index] == nil {
+			vals[index] = d
+			index++
+			continue
+		}
+		newSize := (index + 1) * 2
+		if newSize > len(vals) {
+			newNodes := make([]*TreeNode, (len(vals)+1)*2)
+			copy(newNodes, nodes)
+			nodes = newNodes
+			newVals := make([]int, (len(vals)+1)*2)
+			copy(newVals, vals)
+			vals = newVals
+		}
+		vals[index] = nodes[index].Val
+		if nodes[index].Left != nil {
+			nodeMax = index*2 + 1
+			nodes[index*2+1] = nodes[index].Left
+		}
+		if nodes[index].Right != nil {
+			nodeMax = index*2 + 2
+			nodes[index*2+2] = nodes[index].Right
+		}
+		index++
+	}
+	return vals[:index]
+}
+
 func buildTree(vals []int, x int) *TreeNode {
 	nodes := make([]*TreeNode, len(vals)+1)
 	for i := 0; i < len(vals); i++ {
@@ -18,20 +59,20 @@ func buildTree(vals []int, x int) *TreeNode {
 		nodes[i].Val = vals[i]
 	}
 
-	for i := 0; i < len(vals)/2; i++ {
+	for i := 0; i < len(vals)/2+1; i++ {
 		if nodes[i] == nil {
 			continue
 		}
 		left := i*2 + 1
 		right := left + 1
-		if left > len(vals) {
-			continue
+		if left >= len(vals) {
+			break
 		}
-		nodes[i].Left = nodes[i*2+1]
-		if right > len(vals) {
-			continue
+		nodes[i].Left = nodes[left]
+		if right >= len(vals) {
+			break
 		}
-		nodes[i].Right = nodes[i*2+2]
+		nodes[i].Right = nodes[right]
 	}
 
 	return nodes[0]

go/tree-node_test.go

@@ -0,0 +1,28 @@
+package leetcode
+
+import (
+	"testing"
+)
+
+func TestTree(t *testing.T) {
+	tests := []struct {
+		vals []int
+		x    int
+	}{
+		{
+			vals: []int{8, 5, 10, 1, 7, -1, 12},
+			x:    -1,
+		}, {
+			vals: []int{8},
+			x:    -1,
+		},
+	}
+	for _, item := range tests {
+		root := buildTree(item.vals, item.x)
+		actual := treeToSlice(root, item.x)
+
+		if !intsEqual(actual, item.vals) {
+			t.Fatalf("\nexpect %v \nactual %v\n", item.vals, actual)
+		}
+	}
+}