feat: 701 993

Author: plh97

.vscode/launch.json

@@ -7,9 +7,9 @@
   {
     "type": "node",
     "request": "launch",
-    "name": "nodemon",
-    "runtimeExecutable": "nodemon",
-    "program": "${fileDirname}",
+    "name": "node",
+    "runtimeExecutable": "node",
+    "program": "${fileDirname}/index.js",
     "restart": true,
     "console": "integratedTerminal",
     "internalConsoleOptions": "neverOpen"

algorithm/701.InsertintoaBinarySearchTree/README.md

@@ -0,0 +1,43 @@
+# [701. Insert into a Binary Search Tree](https://leetcode.com/problems/insert-into-a-binary-search-tree/)
+
+## 2019/08/21
+
+### 题目 💗[medium]
+
+Given the root node of a binary search tree (BST) and a value to be inserted into the tree, insert the value into the BST. Return the root node of the BST after the insertion. It is guaranteed that the new value does not exist in the original BST.
+
+Note that there may exist multiple valid ways for the insertion, as long as the tree remains a BST after insertion. You can return any of them.
+
+For example,
+
+```bash
+Given the tree:
+        4
+       / \
+      2   7
+     / \
+    1   3
+And the value to insert: 5
+```
+
+You can return this binary search tree:
+
+```bash
+         4
+       /   \
+      2     7
+     / \   /
+    1   3 5
+```
+
+This tree is also valid:
+
+```bash
+         5
+       /   \
+      2     7
+     / \
+    1   3
+         \
+          4
+```

algorithm/701.InsertintoaBinarySearchTree/main.go

@@ -0,0 +1,25 @@
+package insertIntoBST
+
+import "github.com/pengliheng/leetcode/Helper"
+
+type TreeNode = Helper.TreeNode
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func insertIntoBST(root *TreeNode, val int) *TreeNode {
+	if root == nil {
+		return &TreeNode{Val: val}
+	}
+	if root.Val > val {
+		root.Left = insertIntoBST(root.Left, val)
+	} else {
+		root.Right = insertIntoBST(root.Right, val)
+	}
+	return root
+}

algorithm/701.InsertintoaBinarySearchTree/main_test.go

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

algorithm/993.CousinsinBinaryTree/README.md

@@ -0,0 +1,39 @@
+# [993. Cousins in Binary Tree](https://leetcode.com/problems/cousins-in-binary-tree/)
+
+## 2019/08/21
+
+### 题目 💗[medium]
+
+In a binary tree, the root node is at depth 0, and children of each depth k node are at depth k+1.
+
+Two nodes of a binary tree are cousins if they have the same depth, but have different parents.
+
+We are given the root of a binary tree with unique values, and the values x and y of two different nodes in the tree.
+
+Return true if and only if the nodes corresponding to the values x and y are cousins.
+
+```bash
+Example 1:
+
+Input: root = [1,2,3,4], x = 4, y = 3
+Output: false
+```
+
+```bash
+Example 2:
+
+Input: root = [1,2,3,null,4,null,5], x = 5, y = 4
+Output: true
+```
+
+```bash
+Example 3:
+
+Input: root = [1,2,3,null,4], x = 2, y = 3
+Output: false
+```
+
+Note:
+
+- The number of nodes in the tree will be between 2 and 100.
+- Each node has a unique integer value from 1 to 100.

algorithm/993.CousinsinBinaryTree/main.go

@@ -0,0 +1,37 @@
+package isCousins
+
+import "github.com/pengliheng/leetcode/Helper"
+
+type TreeNode = Helper.TreeNode
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func isCousins(root *TreeNode, x int, y int) bool {
+	xx := -1
+	xxx := -1
+	yy := -2
+	yyy := -2
+	var helper func(*TreeNode, int, int)
+	helper = func(root *TreeNode, depth int, parent int) {
+		if root == nil {
+			return
+		}
+		if xx < 0 && root.Val == x {
+			xx = depth
+			xxx = parent
+		} else if yy < 0 && root.Val == y {
+			yy = depth
+			yyy = parent
+		}
+		helper(root.Left, depth+1, root.Val)
+		helper(root.Right, depth+1, root.Val)
+	}
+	helper(root, 0, -3)
+	return xx == yy && xxx != yyy
+}

algorithm/993.CousinsinBinaryTree/main_test.go

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

index.js

@@ -0,0 +1,41 @@
+var maxDepth = function (root) {
+  if (root.children.length < 1) return 0;
+  return 1 + max(root.children.map(e=>maxDepth(e)))
+};
+
+const max = (arr) => {
+  var res = arr[0]
+  arr.forEach(e => {
+    if (e > res) {
+      res = e
+    }
+  })
+  return res
+}
+
+const res = maxDepth({
+  "$id": "1",
+  "children": [{
+    "$id": "2",
+    "children": [{
+      "$id": "5",
+      "children": [],
+      "val": 5
+    }, {
+      "$id": "6",
+      "children": [],
+      "val": 6
+    }],
+    "val": 3
+  }, {
+    "$id": "3",
+    "children": [],
+    "val": 2
+  }, {
+    "$id": "4",
+    "children": [],
+    "val": 4
+  }],
+  "val": 1
+})
+console.log(res);