feat: 144 230

Author: plh97

algorithm/144.BinaryTreePreorderTraversal/README.md

@@ -0,0 +1,22 @@
+# [144. Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/)
+
+## 2019/08/11
+
+### 题目 💗[medium]
+
+Given a binary tree, return the preorder traversal of its nodes' values.
+
+Example:
+
+```bash
+Input: [1,null,2,3]
+   1
+    \
+     2
+    /
+   3
+
+Output: [1,2,3]
+```
+
+Follow up: Recursive solution is trivial, could you do it iteratively?

algorithm/144.BinaryTreePreorderTraversal/main.go

@@ -0,0 +1,52 @@
+package preorderTraversal
+
+import (
+	"github.com/pengliheng/leetcode/Helper"
+)
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+type TreeNode = Helper.TreeNode
+
+// 		 1
+// 		2 3
+//  4 5 6 7
+// 8
+
+func preorderTraversal(root *TreeNode) []int {
+	s := []*TreeNode{}
+	res := []int{}
+	for root != nil || len(s) > 0 {
+		for root != nil {
+			res = append(res, root.Val)
+			s = append(s, root)
+			root = root.Left
+		}
+		root = s[len(s)-1]
+		s = s[:len(s)-1]
+		root = root.Right
+	}
+	return res
+}
+
+// func preorderTraversal(root *TreeNode) []int {
+//     res:=[]int{}
+//     var helper func(*TreeNode)
+//     helper = func(root *TreeNode) {
+//         if root == nil {
+//             return
+//         }
+//         res = append(res, root.Val)
+//         helper(root.Left)
+//         helper(root.Right)
+//     }
+//     helper(root)
+//     return res
+// }

algorithm/144.BinaryTreePreorderTraversal/main_test.go

@@ -0,0 +1,26 @@
+package preorderTraversal
+
+import (
+	"testing"
+
+	"github.com/pengliheng/leetcode/Helper"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var tcs = []struct {
+	N1  *TreeNode
+	ans []int
+}{
+	{
+		Helper.Ints2TreeNode([]int{1, -1 << 63, 2, 3}),
+		[]int{1, 2, 3},
+	},
+}
+
+func Test_bitwiseComplement(t *testing.T) {
+	ast := assert.New(t)
+	for _, tc := range tcs {
+		ast.Equal(tc.ans, preorderTraversal(tc.N1), "输入:%v", tc)
+	}
+}

algorithm/230.KthSmallestElementinaBST/README.md

@@ -0,0 +1,39 @@
+# [230. Kth Smallest Element in a BST](https://leetcode.com/problems/kth-smallest-element-in-a-bst/)
+
+## 2019/08/11
+
+### 题目 💗[medium]
+
+Given a binary search tree, write a function kthSmallest to find the kth smallest element in it.
+
+Note:
+You may assume k is always valid, 1 ≤ k ≤ BST's total elements.
+
+Example 1:
+
+```bash
+Input: root = [3,1,4,null,2], k = 1
+   3
+  / \
+ 1   4
+  \
+   2
+Output: 1
+```
+
+Example 2:
+
+```bash
+Input: root = [5,3,6,2,4,null,null,1], k = 3
+       5
+      / \
+     3   6
+    / \
+   2   4
+  /
+ 1
+Output: 3
+```
+
+Follow up:
+What if the BST is modified (insert/delete operations) often and you need to find the kth smallest frequently? How would you optimize the kthSmallest routine?

algorithm/230.KthSmallestElementinaBST/main.go

@@ -0,0 +1,32 @@
+package kthSmallest
+
+import (
+	"github.com/pengliheng/leetcode/Helper"
+)
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+type TreeNode = Helper.TreeNode
+
+var min []int
+
+func kthSmallest(root *TreeNode, k int) int {
+	min = []int{}
+	helper(root, k)
+	return min[k-1]
+}
+
+func helper(root *TreeNode, k int) {
+	if root == nil {
+		return
+	}
+	helper(root.Left, k-1)
+	min = append(min, root.Val)
+	helper(root.Right, k-1)
+}

algorithm/230.KthSmallestElementinaBST/main_test.go

@@ -0,0 +1,33 @@
+package kthSmallest
+
+import (
+	"testing"
+
+	"github.com/pengliheng/leetcode/Helper"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var tcs = []struct {
+	N1  *TreeNode
+	N2  int
+	ans int
+}{
+	{
+		Helper.Ints2TreeNode([]int{3, 1, 4, -1 << 63, 2}),
+		1,
+		1,
+	},
+	{
+		Helper.Ints2TreeNode([]int{5, 3, 6, 2, 4, -1 << 63, -1 << 63, 1}),
+		3,
+		3,
+	},
+}
+
+func Test_bitwiseComplement(t *testing.T) {
+	ast := assert.New(t)
+	for _, tc := range tcs {
+		ast.Equal(tc.ans, kthSmallest(tc.N1, tc.N2), "输入:%v", tc)
+	}
+}