Add solution 0530、783

Author: halfrost

README.md

@@ -39,7 +39,7 @@ You may assume **nums1** and **nums2** cannot be both empty.
 
 
 - 给出两个有序数组，要求找出这两个数组合并以后的有序数组中的中位数。要求时间复杂度为 O(log (m+n))。
-- 这一题最容易想到的办法是把两个数组合并，然后取出中位数。但是合并有序数组的操作是 `O(max(n,m))` 的，不符合题意。看到题目给的 `log` 的时间复杂度，很容易联想到二分搜索。
+- 这一题最容易想到的办法是把两个数组合并，然后取出中位数。但是合并有序数组的操作是 `O(m+n)` 的，不符合题意。看到题目给的 `log` 的时间复杂度，很容易联想到二分搜索。
 - 由于要找到最终合并以后数组的中位数，两个数组的总大小也知道，所以中间这个位置也是知道的。只需要二分搜索一个数组中切分的位置，另一个数组中切分的位置也能得到。为了使得时间复杂度最小，所以二分搜索两个数组中长度较小的那个数组。
 - 关键的问题是如何切分数组 1 和数组 2 。其实就是如何切分数组 1 。先随便二分产生一个 `midA`，切分的线何时算满足了中位数的条件呢？即，线左边的数都小于右边的数，即，`nums1[midA-1] ≤ nums2[midB] && nums2[midB-1] ≤ nums1[midA]` 。如果这些条件都不满足，切分线就需要调整。如果 `nums1[midA] < nums2[midB-1]`，说明 `midA` 这条线划分出来左边的数小了，切分线应该右移；如果 `nums1[midA-1] > nums2[midB]`，说明 midA 这条线划分出来左边的数大了，切分线应该左移。经过多次调整以后，切分线总能找到满足条件的解。
 - 假设现在找到了切分的两条线了，`数组 1` 在切分线两边的下标分别是 `midA - 1` 和 `midA`。`数组 2` 在切分线两边的下标分别是 `midB - 1` 和 `midB`。最终合并成最终数组，如果数组长度是奇数，那么中位数就是 `max(nums1[midA-1], nums2[midB-1])`。如果数组长度是偶数，那么中间位置的两个数依次是：`max(nums1[midA-1], nums2[midB-1])` 和 `min(nums1[midA], nums2[midB])`，那么中位数就是 `(max(nums1[midA-1], nums2[midB-1]) + min(nums1[midA], nums2[midB])) / 2`。图示见下图：

leetcode/0004.Median-of-Two-Sorted-Arrays/README.md

@@ -0,0 +1,51 @@
+package leetcode
+
+import (
+	"math"
+
+	"github.com/halfrost/LeetCode-Go/structures"
+)
+
+// TreeNode define
+type TreeNode = structures.TreeNode
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+func getMinimumDifference(root *TreeNode) int {
+	res, nodes := math.MaxInt16, -1
+	dfsBST(root, &res, &nodes)
+	return res
+}
+
+func dfsBST(root *TreeNode, res, pre *int) {
+	if root == nil {
+		return
+	}
+	dfsBST(root.Left, res, pre)
+	if *pre != -1 {
+		*res = min(*res, abs(root.Val-*pre))
+	}
+	*pre = root.Val
+	dfsBST(root.Right, res, pre)
+}
+
+func min(a, b int) int {
+	if a > b {
+		return b
+	}
+	return a
+}
+
+func abs(a int) int {
+	if a > 0 {
+		return a
+	}
+	return -a
+}

leetcode/0530.Minimum-Absolute-Difference-in-BST/530. Minimum Absolute Difference in BST.go

@@ -0,0 +1,56 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/halfrost/LeetCode-Go/structures"
+)
+
+type question530 struct {
+	para530
+	ans530
+}
+
+// para 是参数
+// one 代表第一个参数
+type para530 struct {
+	one []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans530 struct {
+	one int
+}
+
+func Test_Problem530(t *testing.T) {
+
+	qs := []question530{
+
+		{
+			para530{[]int{4, 2, 6, 1, 3}},
+			ans530{1},
+		},
+
+		{
+			para530{[]int{1, 0, 48, structures.NULL, structures.NULL, 12, 49}},
+			ans530{1},
+		},
+
+		{
+			para530{[]int{90, 69, structures.NULL, 49, 89, structures.NULL, 52}},
+			ans530{1},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 530------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans530, q.para530
+		fmt.Printf("【input】:%v      ", p)
+		rootOne := structures.Ints2TreeNode(p.one)
+		fmt.Printf("【output】:%v      \n", getMinimumDifference(rootOne))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/0530.Minimum-Absolute-Difference-in-BST/530. Minimum Absolute Difference in BST_test.go

@@ -0,0 +1,94 @@
+# [530. Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/)
+
+
+## 题目
+
+Given a binary search tree with non-negative values, find the minimum [absolute difference](https://en.wikipedia.org/wiki/Absolute_difference) between values of any two nodes.
+
+**Example:**
+
+```
+Input:
+
+   1
+    \
+     3
+    /
+   2
+
+Output:
+1
+
+Explanation:
+The minimum absolute difference is 1, which is the difference between 2 and 1 (or between 2 and 3).
+```
+
+**Note:**
+
+- There are at least two nodes in this BST.
+- This question is the same as 783: [https://leetcode.com/problems/minimum-distance-between-bst-nodes/](https://leetcode.com/problems/minimum-distance-between-bst-nodes/)
+
+## 题目大意
+
+给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。
+
+## 解题思路
+
+- 由于是 BST 树，利用它有序的性质，中根遍历的结果是有序的。中根遍历过程中动态维护前后两个节点的差值，即可找到最小差值。
+- 此题与第 783 题完全相同。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+	"math"
+
+	"github.com/halfrost/LeetCode-Go/structures"
+)
+
+// TreeNode define
+type TreeNode = structures.TreeNode
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+func getMinimumDifference(root *TreeNode) int {
+	res, nodes := math.MaxInt16, -1
+	dfsBST(root, &res, &nodes)
+	return res
+}
+
+func dfsBST(root *TreeNode, res, pre *int) {
+	if root == nil {
+		return
+	}
+	dfsBST(root.Left, res, pre)
+	if *pre != -1 {
+		*res = min(*res, abs(root.Val-*pre))
+	}
+	*pre = root.Val
+	dfsBST(root.Right, res, pre)
+}
+
+func min(a, b int) int {
+	if a > b {
+		return b
+	}
+	return a
+}
+
+func abs(a int) int {
+	if a > 0 {
+		return a
+	}
+	return -a
+}
+```

leetcode/0530.Minimum-Absolute-Difference-in-BST/README.md

@@ -0,0 +1,51 @@
+package leetcode
+
+import (
+	"math"
+
+	"github.com/halfrost/LeetCode-Go/structures"
+)
+
+// TreeNode define
+type TreeNode = structures.TreeNode
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+func minDiffInBST(root *TreeNode) int {
+	res, nodes := math.MaxInt16, -1
+	dfsBST(root, &res, &nodes)
+	return res
+}
+
+func dfsBST(root *TreeNode, res, pre *int) {
+	if root == nil {
+		return
+	}
+	dfsBST(root.Left, res, pre)
+	if *pre != -1 {
+		*res = min(*res, abs(root.Val-*pre))
+	}
+	*pre = root.Val
+	dfsBST(root.Right, res, pre)
+}
+
+func min(a, b int) int {
+	if a > b {
+		return b
+	}
+	return a
+}
+
+func abs(a int) int {
+	if a > 0 {
+		return a
+	}
+	return -a
+}

leetcode/0783.Minimum-Distance-Between-BST-Nodes/783. Minimum Distance Between BST Nodes.go

@@ -0,0 +1,56 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/halfrost/LeetCode-Go/structures"
+)
+
+type question783 struct {
+	para783
+	ans783
+}
+
+// para 是参数
+// one 代表第一个参数
+type para783 struct {
+	one []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans783 struct {
+	one int
+}
+
+func Test_Problem783(t *testing.T) {
+
+	qs := []question783{
+
+		{
+			para783{[]int{4, 2, 6, 1, 3}},
+			ans783{1},
+		},
+
+		{
+			para783{[]int{1, 0, 48, structures.NULL, structures.NULL, 12, 49}},
+			ans783{1},
+		},
+
+		{
+			para783{[]int{90, 69, structures.NULL, 49, 89, structures.NULL, 52}},
+			ans783{1},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 783------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans783, q.para783
+		fmt.Printf("【input】:%v      ", p)
+		rootOne := structures.Ints2TreeNode(p.one)
+		fmt.Printf("【output】:%v      \n", minDiffInBST(rootOne))
+	}
+	fmt.Printf("\n\n\n")
+}