Add linked-list-in-binary-tree

Author: beyondyyh

algorithms/README.md

@@ -40,7 +40,7 @@
 |0148|[排序链表](https://leetcode-cn.com/problems/sort-list/)|[go](./linkedList/148.sortList.go)|M|
 |0155|[最小栈](https://leetcode-cn.com/problems/min-stack/)|[go](./mystack/155.minStack.go)|S|
 |0171|[Excel表列序号](https://leetcode-cn.com/problems/excel-sheet-column-number/)|[go](./mystring/171.titleToNumber.go)|S|
-|0173|[二叉搜索树迭代器](https://leetcode-cn.com/problems/binary-search-tree-iterator/)|[go](./mystack/173.BSTIterator.go)|M|
+|0173|[二叉搜索树迭代器](https://leetcode-cn.com/problems/binary-search-tree-iterator/)|[go](./tree/173.BSTIterator.go) [go](./mystack/173.BSTIterator.go)|M|
 |0206|[反转链表](https://leetcode-cn.com/problems/reverse-linked-list/)|[go](./linkedList/206.reverseList.go)|S|
 |0208|[实现 Trie (前缀树)](https://leetcode-cn.com/problems/implement-trie-prefix-tree/)|[go](./trie/208.trie.go)|M|
 |0215|[数组中的第K个最大元素](https://leetcode-cn.com/problems/kth-largest-element-in-an-array/)|[go](./myheap/215.findKthLargest.go)|M|
@@ -67,4 +67,5 @@
 |1021|[删除最外层的括号](https://leetcode-cn.com/problems/remove-outermost-parentheses/)|[go](./mystack/1021.removeOuterParentheses.go)|S|
 |1108|[地址无效化](https://leetcode-cn.com/problems/defanging-an-ip-address/)|[go](./mystring/1108.defangIPaddr.go)|S|
 |1213|[三个有序数组的交集](https://leetcode-cn.com/problems/intersection-of-three-sorted-arrays/)|[go](./myarray/1213.arraysIntersection.go)|S|
+|1367|[二叉树中的列表](https://leetcode-cn.com/problems/linked-list-in-binary-tree/)|[go](./tree/1367.isSubPath.go)|M|
 ||||[:top:](#Top)|

algorithms/kit/ListNode.go

@@ -12,12 +12,17 @@ func NewListNode(val int) *ListNode {
 
 // Ints2List convert []int to List
 func Ints2List(nums []int) *ListNode {
+	if len(nums) == 0 {
+		return nil
+	}
+
 	dummy := &ListNode{Val: -1}
 	curr := dummy
 	for _, num := range nums {
 		curr.Next = &ListNode{Val: num}
 		curr = curr.Next
 	}
+
 	return dummy.Next
 }
 

algorithms/mystack/173.BSTIterator_test.go

@@ -3,9 +3,9 @@ package mystack
 import (
 	"testing"
 
-	"Leetcode/algorithms/kit"
-
 	"github.com/stretchr/testify/assert"
+
+	"Leetcode/algorithms/kit"
 )
 
 // run: go test -v base.go 173.*

algorithms/tree/1367.isSubPath.go

@@ -0,0 +1,33 @@
+package tree
+
+// 判断一个树是否存在链表的路径
+func isSubPath(head *ListNode, root *TreeNode) bool {
+	if root == nil {
+		return false
+	}
+
+	// 先判断当前的节点，如果不对，再看左右子树
+	return isMatch(head, root) || isSubPath(head, root.Left) || isSubPath(head, root.Right)
+}
+
+// 判断二叉树中的每个节点为起点往下的路径是否与链表相匹配
+// head表示当前已经匹配到的链表节点，root表示二叉树的节点
+func isMatch(head *ListNode, root *TreeNode) bool {
+	// 特判1：链表走完了，返回true
+	if head == nil {
+		return true
+	}
+
+	// 特判2：链表没走完，树走完了，这肯定不行啊，返回false
+	if root == nil {
+		return false
+	}
+
+	// 特判3：值不同，必定不是啊
+	if head.Val != root.Val {
+		return false
+	}
+
+	// 正常逻辑：如果值相同，继续走，左子树和右子树有一个满足即可
+	return isMatch(head.Next, root.Left) || isMatch(head.Next, root.Right)
+}

algorithms/tree/1367.isSubPath_test.go

@@ -0,0 +1,55 @@
+package tree
+
+import (
+	"Leetcode/algorithms/kit"
+	"testing"
+)
+
+// run: go test -v -run Test_isSubPath
+func Test_isSubPath(t *testing.T) {
+	cases := []kit.CaseEntry{
+		{
+			Name: "x1",
+			Input: map[string]interface{}{
+				"head": []int{},
+				"root": []int{1, 4, 4, null, 2, 2, null, 1, null, 6, 8, null, null, null, null, 1, 3},
+			},
+			Expected: true,
+		},
+		{
+			Name: "x2",
+			Input: map[string]interface{}{
+				"head": []int{4, 2, 8},
+				"root": []int{1, 4, 4, null, 2, 2, null, 1, null, 6, 8, null, null, null, null, 1, 3},
+			},
+			Expected: true,
+		},
+		{
+			Name: "x3",
+			Input: map[string]interface{}{
+				"head": []int{1, 4, 2, 6},
+				"root": []int{1, 4, 4, null, 2, 2, null, 1, null, 6, 8, null, null, null, null, 1, 3},
+			},
+			Expected: true,
+		},
+		{
+			Name: "x4",
+			Input: map[string]interface{}{
+				"head": []int{1, 4, 2, 6, 8},
+				"root": []int{1, 4, 4, null, 2, 2, null, 1, null, 6, 8, null, null, null, null, 1, 3},
+			},
+			Expected: false,
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.Name, func(t *testing.T) {
+			input := c.Input.(map[string]interface{})
+			head := kit.Ints2List(input["head"].([]int))
+			root := kit.Ints2Tree(input["root"].([]int))
+			if output := isSubPath(head, root); output != c.Expected.(bool) {
+				t.Errorf("isSubPath()=%t, expected=%t", output, c.Expected)
+			}
+		})
+	}
+}

algorithms/tree/173.BSTIterator.go

@@ -0,0 +1,31 @@
+package tree
+
+// 二叉搜索树（Binary Search Tree）又叫 `二叉排序树` 他是一颗空树 或者具有以下特点：
+// 1. 针对某个节点，根节点上的值大于等于左子树的值，小于等于右子树的值
+// 2. 他的左右子树也分别是二叉排序树
+// 通过 `中序遍历` 可以得到一个升序的数组，这点很重要
+
+import (
+	"Leetcode/algorithms/kit"
+)
+
+type BSTIterator struct {
+	index int
+	nums  []int
+}
+
+func NewBSTIterator(root *TreeNode) *BSTIterator {
+	return &BSTIterator{
+		index: -1,
+		nums:  kit.Tree2Inorder(root),
+	}
+}
+
+func (it *BSTIterator) Next() int {
+	it.index += 1
+	return it.nums[it.index]
+}
+
+func (it *BSTIterator) HasNext() bool {
+	return it.index+1 < len(it.nums)
+}

algorithms/tree/173.BSTIterator_test.go

@@ -0,0 +1,25 @@
+package tree
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"Leetcode/algorithms/kit"
+)
+
+// run: go test -v -run Test_BSTIterator
+func Test_BSTIterator(t *testing.T) {
+	assert := assert.New(t)
+	ints := []int{7, 3, 15, null, null, 9, 20}
+	root := kit.Ints2Tree(ints)
+
+	nums := kit.Tree2Inorder(root)
+
+	var i int
+	it := NewBSTIterator(root)
+	for it.HasNext() {
+		assert.Equal(nums[i], it.Next(), "%d", nums[i])
+		i++
+	}
+}

algorithms/tree/base.go

@@ -14,4 +14,5 @@ type TreeNode = kit.TreeNode
 // Stack ...
 type Stack = kit.Stack
 
-// var TreeNode = kit.TreeNode
+// ListNode
+type ListNode = kit.ListNode