064

Author: Dinghao LI

063-二叉搜索树的第K个结点/README.md

@@ -0,0 +1,14 @@
+# 题意
+
+
+```
+ 	5 
+   / \ 
+  3   7 
+ / \  /\ 
+2  4  6 8 
+```
+
+给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8）    中，按结点数值大小顺序第三小结点的值为4。
+
+二叉搜索树的中序遍历正好是一个递增的序列，因此中序遍历的第K个结点就是二叉搜索树的第K个节点

063-二叉搜索树的第K个结点/problem063.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+)
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func getKth(root *TreeNode, k int) *TreeNode {
+	if root == nil || k<1 {
+		return nil
+	}
+	var res *TreeNode
+	found := false
+	var inOrder func(*TreeNode)
+	inOrder = func(node *TreeNode) {
+		if found == true || node == nil {
+			return
+		}
+		inOrder(node.Left)
+		if k == 1 {
+			res = node
+			found = true
+		}
+		k--
+		inOrder(node.Right)
+	}
+	inOrder(root)	
+	return res
+}
+
+
+func print(root *TreeNode) {
+	if root == nil {
+		return
+	}
+	print(root.Left)
+	fmt.Printf("%d -> ", root.Val)
+	print(root.Right)
+}
+
+func main() {
+	// q1    5
+	// q2  3   7
+	// q1 1 4 6 8
+	root := &TreeNode{5, &TreeNode{3, &TreeNode{1, nil, nil}, &TreeNode{4, nil, nil}}, &TreeNode{7, &TreeNode{6, nil, nil}, &TreeNode{8, nil, nil}}}
+	print(root)
+	fmt.Println("")
+	fmt.Println("Get 1th: ", getKth(root, 1).Val)
+	fmt.Println("Get 2th: ", getKth(root, 2).Val)
+	fmt.Println("Get 3th: ", getKth(root, 3).Val)
+	fmt.Println("Get 4th: ", getKth(root, 4).Val)
+	fmt.Println("Get 5th: ", getKth(root, 5).Val)
+	fmt.Println("Get 6th: ", getKth(root, 6).Val)
+	fmt.Println("Get 7th: ", getKth(root, 7).Val)
+	fmt.Println("Get 8th: ", getKth(root, 8))
+
+
+}

064-数据流之中的中位数/README.md

@@ -0,0 +1,11 @@
+# 题意
+
+题目描述
+
+如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
+
+# 堆排序策略
+
+对于数据流，对应的就是在线算法了，一道很经典的题目就是在1亿个数中找到最大的前100个数，这是一道堆应用题，找最大的前100个数，那么我们就创建一个大小为100的最小化堆，每来一个元素就与堆顶元素比较，因为堆顶元素是目前前100大数中的最小数，前来的元素如果比该元素大，那么就把原来的堆顶替换掉。
+
+那么对于这一道题呢？如果单纯的把所有元素放到一个数组里，每次查找中位数最快也要O(n)，综合下来是O(n^2)的复杂度。我们可以利用上面例子中的想法，用一个最大堆来维护当前前n/2小的元素，那么每次找中位数只到取出堆顶就可以了。但是，有一个问题，数据要动态增长，有可能之前被替换掉的元素随着元素的增加又跑回来了，所以我们不能单纯得向上题一样把元素丢掉，我们可以再用一个最小化堆来存前n/2大的元素。

064-数据流之中的中位数/problem064.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"../utils"
+	"fmt"
+)
+
+type Solution struct {
+	max *utils.MaxHeap
+	min *utils.MinHeap
+}
+
+func (s *Solution) Insert(num int) {
+	if ((s.max.Length() + s.min.Length()) & 1) == 0 {
+		// 偶数数据的情况下
+		// 直接将新的数据插入到数组的后半段
+		// 即在最小堆中插入元素
+		// 此时最小堆中多出一个元素,
+		// 即最小元素, 将其弹出后, 压入前半段(即最大堆中)
+		if s.max.Length() > 0 && num < s.max.GetMax() {
+			s.max.Insert(num)
+			val, _ := s.max.DeleteMax()
+			s.min.Insert(val)
+		} else {
+			s.min.Insert(num)
+		}
+	} else {
+		// 奇数情况
+		if s.max.Length() > 0 && num < s.max.GetMax() {
+			s.max.Insert(num)
+		} else {
+			s.min.Insert(num)
+			val, _ := s.min.DeleteMin()
+			s.max.Insert(val)
+		}
+	}
+}
+
+func (s *Solution) GetMedian() float64 {
+	size := s.max.Length() + s.min.Length()
+	if size == 0 {
+		return -1
+	}
+	var median float64
+	if size&1 != 0 {
+		median = float64(s.min.GetMin())
+	} else {
+		median = float64(s.min.GetMin() + s.max.GetMax()) / 2
+	}
+	return median
+}
+
+
+func main() {
+
+	sol := &Solution{utils.NewMaxHeap(), utils.NewMinHeap()}
+	sol.Insert(1)
+	fmt.Println("Insert 1")
+	fmt.Println(sol.GetMedian())
+
+	sol.Insert(2)
+	fmt.Println("Insert 2")
+	fmt.Println(sol.GetMedian())
+
+	sol.Insert(3)
+	fmt.Println("Insert 3")
+	fmt.Println(sol.GetMedian())
+
+	sol.Insert(4)
+	fmt.Println("Insert 4")
+	fmt.Println(sol.GetMedian())
+
+	sol.Insert(5)
+	fmt.Println("Insert 5")
+	fmt.Println(sol.GetMedian())
+
+}

utils/maxHeap.go

@@ -31,6 +31,14 @@ func (H *MaxHeap) Max() (int, error) {
 	return -1, fmt.Errorf("heap is empty")
 }
 
+// Get the Maximum of the Maxheap
+func (H *MaxHeap) GetMax() int {
+	if H.Length() > 0 {
+		return H.Element[1]
+	}
+	return math.MaxInt64
+}
+
 // Inserting items requires ensuring the nature of the Maxheap
 func (H *MaxHeap) Insert(v int) {
 	H.Element = append(H.Element, v)

utils/minHeap.go

@@ -0,0 +1,75 @@
+package utils
+
+import (
+	"fmt"
+	"math"
+)
+
+type MinHeap struct {
+	Element []int
+}
+
+
+
+// MinHeap constructor
+func NewMinHeap() *MinHeap {
+	first := math.MinInt64
+	h := &MinHeap{Element: []int{first}}
+	return h
+}
+
+// Length of Minheap
+func (H *MinHeap) Length() int {
+	return len(H.Element) - 1
+}
+
+// Get the Minimum of the Minheap
+func (H *MinHeap) Min() (int, error) {
+	if len(H.Element) > 1 {
+		return H.Element[1], nil
+	}
+	return -1, fmt.Errorf("heap is empty")
+}
+
+// Get the Minimum of the Minheap
+func (H *MinHeap) GetMin() int {
+	if H.Length() > 0 {
+		return H.Element[1]
+	}
+	return math.MinInt64
+}
+
+// Inserting items requires ensuring the nature of the Minheap
+func (H *MinHeap) Insert(v int) {
+	H.Element = append(H.Element, v)
+	i := len(H.Element) - 1
+	for ; (H.Element[i/2]) > v; i /= 2 {
+		H.Element[i] = H.Element[i/2]
+	}
+
+	H.Element[i] = v
+}
+
+// Delete and return the Minimum
+func (H *MinHeap) DeleteMin() (int, error) {
+	if len(H.Element) <= 1 {
+		return -1, fmt.Errorf("MinHeap is empty")
+	}
+	MinElement := H.Element[1]
+	lastElement := H.Element[len(H.Element)-1]
+	var i, child int
+	for i = 1; i*2 < len(H.Element); i = child {
+		child = i * 2
+		if child < len(H.Element)-1 && H.Element[child+1] < H.Element[child] {
+			child++
+		}
+		if lastElement > H.Element[child] {
+			H.Element[i] = H.Element[child]
+		} else {
+			break
+		}
+	}
+	H.Element[i] = lastElement
+	H.Element = H.Element[:len(H.Element)-1]
+	return MinElement, nil
+}

utils/minHeap_test.go

@@ -0,0 +1,65 @@
+package utils
+
+import (
+	"testing"
+	"fmt"
+)
+
+func Test_MinHeap(t *testing.T) {
+	heap := NewMinHeap()
+	if heap.Length() == 0 {
+		t.Log("Pass")
+	} else {
+		t.Error("Failed")
+	}
+
+	heap.Insert(1)
+	heap.Insert(2)
+	heap.Insert(3)
+	heap.Insert(4)
+	heap.Insert(5)
+
+
+	if heap.Length() == 5 {
+		t.Log("Pass")
+	} else {
+		t.Error("Failed")
+	}
+
+	v, _ := heap.Min()
+	if v == 1 {
+		t.Log("Pass")
+	} else {
+		t.Error("Failed")
+	}
+
+	v, _ = heap.DeleteMin()
+	if v == 1 {
+		t.Log("Pass")
+	} else {
+		t.Error("Failed")
+	}
+
+	v, _ = heap.DeleteMin()
+	if v == 2 {
+		t.Log("Pass")
+	} else {
+		fmt.Println(v)
+		t.Error("Failed")
+	}
+	v, _ = heap.DeleteMin()
+	if v == 3 {
+		t.Log("Pass")
+	} else {
+		fmt.Println(v)
+		t.Error("Failed")
+	}
+	v, _ = heap.DeleteMin()
+	if v == 4 {
+		t.Log("Pass")
+	} else {
+		fmt.Println(v)
+		t.Error("Failed")
+	}
+
+}