feat(solutions): add convert_sorted_array_to_binary_search_tree

Author: WindomZ

README.md

@@ -34,6 +34,7 @@ If you like it then you can put a :star:**Star** on it.
 
 | # | **Problem** & **Solution** | Difficulty | Single Repetition Duration | LeetCode Run Time |
 | ---: | :----- | :----------: | ----------: | ----------: |
+|[108][Solutions-108]|[Convert Sorted Array to Binary Search Tree][Solutions-108-Home]|Easy|[138 ns/op][Solutions-108-Code] / [5 test cases][Solutions-108-Test]|204 ms|
 |[107][Solutions-107]|[Binary Tree Level Order Traversal II][Solutions-107-Home]|Easy|[102 ns/op][Solutions-107-Code] / [3 test cases][Solutions-107-Test]|8 ms|
 |[106][Solutions-106]|[Construct Binary Tree from Inorder and Postorder Traversal][Solutions-106-Home]|Medium|[60.0 ns/op][Solutions-106-Code] / [3 test cases][Solutions-106-Test]|32 ms|
 |[105][Solutions-105]|[Construct Binary Tree from Preorder and Inorder Traversal][Solutions-105-Home]|Medium|[60.0 ns/op][Solutions-105-Code] / [3 test cases][Solutions-105-Test]|36 ms|
@@ -163,6 +164,10 @@ Welcome to report bugs, suggest ideas and discuss on [issues page](https://githu
 ## License
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2FWindomZ%2Fleetcode.go.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2FWindomZ%2Fleetcode.go?ref=badge_large)
 
+[Solutions-108]:https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/
+[Solutions-108-Home]:solutions/convert_sorted_array_to_binary_search_tree/
+[Solutions-108-Code]:solutions/convert_sorted_array_to_binary_search_tree/convertsortedarraytobinarysearchtree.go
+[Solutions-108-Test]:solutions/convert_sorted_array_to_binary_search_tree/convertsortedarraytobinarysearchtree_test.go#L59
 [Solutions-107]:https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
 [Solutions-107-Home]:solutions/binary_tree_level_order_traversal_ii/
 [Solutions-107-Code]:solutions/binary_tree_level_order_traversal_ii/binarytreelevelordertraversalii.go

solutions/convert_sorted_array_to_binary_search_tree/NOTE_Ch-zh.md

@@ -0,0 +1,3 @@
+# 解法要点
+1. 二分法解法思想，通过递归处理叶分支
+1. 注意中间值越界的处理

solutions/convert_sorted_array_to_binary_search_tree/README.md

@@ -0,0 +1,26 @@
+# [108. Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
+
+## Description
+
+Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
+
+For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of _every_ node never differ by more than 1.
+
+**Example:**
+
+Given the sorted array: [-10,-3,0,5,9],
+
+One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:
+
+      0
+     / \
+   -3   9
+   /   /
+ -10  5
+
+## Solution
+- [Code](convertsortedarraytobinarysearchtree.go)
+- [Testing](convertsortedarraytobinarysearchtree_test.go)
+
+## Note
+- [中文](NOTE_Ch-zh.md)

solutions/convert_sorted_array_to_binary_search_tree/convertsortedarraytobinarysearchtree.go

@@ -0,0 +1,30 @@
+package convertsortedarraytobinarysearchtree
+
+// TreeNode definition for a binary tree node.
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func sortedArrayToBST(nums []int) *TreeNode {
+	if len(nums) == 0 {
+		return nil
+	}
+	return sortedArray(&nums, 0, len(nums)-1)
+}
+
+func sortedArray(nums *[]int, low, high int) *TreeNode {
+	if low > high { // Done
+		return nil
+	}
+	mid := low + (high-low)/2
+	if (high-low)%2 != 0 {
+		mid++
+	}
+	return &TreeNode{
+		Val:   (*nums)[mid],
+		Left:  sortedArray(nums, low, mid-1),
+		Right: sortedArray(nums, mid+1, high),
+	}
+}

solutions/convert_sorted_array_to_binary_search_tree/convertsortedarraytobinarysearchtree_test.go

@@ -0,0 +1,72 @@
+package convertsortedarraytobinarysearchtree
+
+import (
+	"testing"
+
+	"github.com/WindomZ/testify/assert"
+)
+
+func Test_sortedArrayToBST(t *testing.T) {
+	assert.Empty(t, sortedArrayToBST(nil))
+	assert.Empty(t, sortedArrayToBST([]int{}))
+	assert.Equal(t, &TreeNode{
+		Val: 1,
+	}, sortedArrayToBST([]int{1}))
+	assert.Equal(t, &TreeNode{
+		Val: 2,
+		Left: &TreeNode{
+			Val: 1,
+		},
+	}, sortedArrayToBST([]int{1, 2}))
+	assert.Equal(t, &TreeNode{
+		Val: 0,
+		Left: &TreeNode{
+			Val: -3,
+			Left: &TreeNode{
+				Val: -10,
+			},
+		},
+		Right: &TreeNode{
+			Val: 9,
+			Left: &TreeNode{
+				Val: 5,
+			},
+		},
+	}, sortedArrayToBST([]int{-10, -3, 0, 5, 9}))
+	assert.Equal(t, &TreeNode{
+		Val: 0,
+		Left: &TreeNode{
+			Val: -10,
+			Left: &TreeNode{
+				Val: -11,
+			},
+			Right: &TreeNode{
+				Val: -3,
+			},
+		},
+		Right: &TreeNode{
+			Val: 9,
+			Left: &TreeNode{
+				Val: 5,
+			},
+			Right: &TreeNode{
+				Val: 12,
+			},
+		},
+	}, sortedArrayToBST([]int{-11, -10, -3, 0, 5, 9, 12}))
+}
+
+func Benchmark_sortedArrayToBST(b *testing.B) {
+	b.StopTimer()
+	b.ReportAllocs()
+	b.StartTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			sortedArrayToBST([]int{})
+			sortedArrayToBST([]int{1})
+			sortedArrayToBST([]int{1, 2})
+			sortedArrayToBST([]int{-10, -3, 0, 5, 9})
+			sortedArrayToBST([]int{-11, -10, -3, 0, 5, 9, 12})
+		}
+	})
+}