Merge branch 'develop' of https://github.com/aQuaYi/LeetCode-in-Go into develop

Author: aQuaYi

Algorithms/0895.maximum-frequency-stack/README.md

@@ -0,0 +1,46 @@
+# [895. Maximum Frequency Stack](https://leetcode.com/problems/maximum-frequency-stack/)
+
+## 题目
+
+Implement FreqStack, a class which simulates the operation of a stack-like data structure.
+
+FreqStack`has two functions:
+
+- push(int x), which pushes an integer x onto the stack.
+- pop(), which removes and returns the most frequent element in the stack.
+  - If there is a tie for most frequent element, the element closest to the top of the stack is removed and returned.
+
+Example 1:
+
+```text
+Input:
+["FreqStack","push","push","push","push","push","push","pop","pop","pop","pop"],
+[[],[5],[7],[5],[7],[4],[5],[],[],[],[]]
+Output: [null,null,null,null,null,null,null,5,7,5,4]
+Explanation:
+After making six .push operations, the stack is [5,7,5,7,4,5] from bottom to top.  Then:
+
+pop() -> returns 5, as 5 is the most frequent.
+The stack becomes [5,7,5,7,4].
+
+pop() -> returns 7, as 5 and 7 is the most frequent, but 7 is closest to the top.
+The stack becomes [5,7,5,4].
+
+pop() -> returns 5.
+The stack becomes [5,7,4].
+
+pop() -> returns 4.
+The stack becomes [5,7].
+```
+
+Note:
+
+- Calls to FreqStack.push(int x)`will be such that 0 <= x <= 10^9.
+- It is guaranteed that FreqStack.pop() won't be called if the stack has zero elements.
+- The total number of FreqStack.push calls will not exceed 10000 in a single test case.
+- The total number of FreqStack.pop`calls will not exceed 10000 in a single test case.
+- The total number of FreqStack.push and FreqStack.pop calls will not exceed 150000 across all test cases.
+
+## 解题思路
+
+见程序注释

Algorithms/0895.maximum-frequency-stack/maximum-frequency-stack.go

@@ -0,0 +1,77 @@
+package problem0895
+
+import (
+	"container/heap"
+)
+
+// FreqStack object will be instantiated and called as such:
+// obj := Constructor();
+// obj.Push(x);
+// param_2 := obj.Pop();
+type FreqStack struct {
+	index int
+	freq  map[int]int
+	pq    *PQ
+}
+
+// Constructor 构建 FreqStack
+func Constructor() FreqStack {
+	pq := make(PQ, 0, 10000)
+	return FreqStack{
+		freq: make(map[int]int, 10000),
+		pq:   &pq,
+	}
+}
+
+// Push 在 fs 中放入 x
+func (fs *FreqStack) Push(x int) {
+	fs.index++
+	fs.freq[x]++
+	e := &entry{
+		key:   x,
+		index: fs.index,
+		freq:  fs.freq[x],
+	}
+	heap.Push(fs.pq, e)
+}
+
+// Pop 从 fs 中弹出元素
+func (fs *FreqStack) Pop() int {
+	x := heap.Pop(fs.pq).(*entry).key
+	fs.freq[x]--
+	return x
+}
+
+// entry 是 priorityQueue 中的元素
+type entry struct {
+	key, index, freq int
+}
+
+// PQ implements heap.Interface and holds entries.
+type PQ []*entry
+
+func (pq PQ) Len() int { return len(pq) }
+
+func (pq PQ) Less(i, j int) bool {
+	if pq[i].freq == pq[j].freq {
+		return pq[i].index > pq[j].index
+	}
+	return pq[i].freq > pq[j].freq
+}
+
+func (pq PQ) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+}
+
+// Push 往 pq 中放 entry
+func (pq *PQ) Push(x interface{}) {
+	temp := x.(*entry)
+	*pq = append(*pq, temp)
+}
+
+// Pop 从 pq 中取出最优先的 entry
+func (pq *PQ) Pop() interface{} {
+	temp := (*pq)[len(*pq)-1]
+	*pq = (*pq)[0 : len(*pq)-1]
+	return temp
+}

Algorithms/0895.maximum-frequency-stack/maximum-frequency-stack_test.go

@@ -0,0 +1,46 @@
+package problem0895
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_FreqStack_1(t *testing.T) {
+	ast := assert.New(t)
+	fs := Constructor()
+	pushes := []int{5, 7, 5, 7, 4, 5}
+	for _, p := range pushes {
+		fs.Push(p)
+	}
+	expecteds := []int{5, 7, 5, 4}
+	for _, expected := range expecteds {
+		actual := fs.Pop()
+		ast.Equal(expected, actual)
+	}
+}
+
+func Test_FreqStack_2(t *testing.T) {
+	ast := assert.New(t)
+	fs := Constructor()
+	//
+	pushes := []int{1, 1, 1, 2}
+	for _, p := range pushes {
+		fs.Push(p)
+	}
+	expecteds := []int{1, 1}
+	for _, expected := range expecteds {
+		actual := fs.Pop()
+		ast.Equal(expected, actual)
+	}
+	//
+	pushes = []int{2, 2, 1}
+	for _, p := range pushes {
+		fs.Push(p)
+	}
+	expecteds = []int{2, 1, 2}
+	for _, expected := range expecteds {
+		actual := fs.Pop()
+		ast.Equal(expected, actual)
+	}
+}

Algorithms/0897.increasing-order-search-tree/README.md

@@ -0,0 +1,47 @@
+# [897. Increasing Order Search Tree](https://leetcode.com/problems/increasing-order-search-tree/)
+
+## 题目
+
+Given a tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only 1 right child.
+
+```text
+Example 1:
+Input: [5,3,6,2,4,null,8,1,null,null,null,7,9]
+
+       5
+      / \
+    3    6
+   / \    \
+  2   4    8
+ /        / \
+1        7   9
+
+Output: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
+
+1
+ \
+  2
+   \
+    3
+     \
+      4
+       \
+        5
+         \
+          6
+           \
+            7
+             \
+              8
+               \
+                 9
+```
+
+Note:
+
+- The number of nodes in the given tree will be between 1 and 100.
+- Each node will have a unique integer value from 0 to 1000.
+
+## 解题思路
+
+见程序注释

Algorithms/0897.increasing-order-search-tree/increasing-order-search-tree.go

@@ -0,0 +1,28 @@
+package problem0897
+
+import "github.com/aQuaYi/LeetCode-in-Go/kit"
+
+// TreeNode Definition for a binary tree node.
+// type TreeNode struct {
+//     Val int
+//     Left *TreeNode
+//     Right *TreeNode
+// }
+type TreeNode = kit.TreeNode
+
+func increasingBST(root *TreeNode) *TreeNode {
+	var head = &TreeNode{}
+	tail := head
+	var rec func(root *TreeNode)
+	rec = func(root *TreeNode) {
+		if root == nil {
+			return
+		}
+		rec(root.Left)
+		root.Left = nil               // 切断 root 与其 Left 的连接，避免形成环
+		tail.Right, tail = root, root // 把 root 接上 tail，并保持 tail 指向尾部
+		rec(root.Right)
+	}
+	rec(root)
+	return head.Right
+}

Algorithms/0897.increasing-order-search-tree/increasing-order-search-tree_test.go

@@ -0,0 +1,45 @@
+package problem0897
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aQuaYi/LeetCode-in-Go/kit"
+	"github.com/stretchr/testify/assert"
+)
+
+var null = kit.NULL
+
+// tcs is testcase slice
+var tcs = []struct {
+	p   []int
+	ans []int
+}{
+
+	{
+		[]int{5, 3, 6, 2, 4, null, 8, 1, null, null, null, 7, 9},
+		[]int{1, null, 2, null, 3, null, 4, null, 5, null, 6, null, 7, null, 8, null, 9},
+	},
+
+	// 可以有多个 testcase
+}
+
+func Test_increasingBST(t *testing.T) {
+	ast := assert.New(t)
+
+	for _, tc := range tcs {
+		fmt.Printf("~~%v~~\n", tc)
+		root := kit.Ints2TreeNode(tc.p)
+		ans := kit.Tree2ints(increasingBST(root))
+		ast.Equal(tc.ans, ans, "输入:%v", tc)
+	}
+}
+
+func Benchmark_myFunc(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, tc := range tcs {
+			root := kit.Ints2TreeNode(tc.p)
+			increasingBST(root)
+		}
+	}
+}

Algorithms/0905.sort-array-by-parity/README.md

@@ -0,0 +1,24 @@
+# [905. Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/)
+
+## 题目
+
+Given an array `A` of non-negative integers, return an array consisting of all the even elements of `A`, followed by all the odd elements of `A`.
+
+You may return any answer array that satisfies this condition.
+
+Example 1:
+
+```text
+Input: [3,1,2,4]
+Output: [2,4,3,1]
+The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
+```
+
+Note:
+
+- 1 <= A.length <= 5000
+- 0 <= A[i] <= 5000
+
+## 解题思路
+
+见程序注释

Algorithms/0905.sort-array-by-parity/sort-array-by-parity.go

@@ -0,0 +1,21 @@
+package problem0905
+
+func sortArrayByParity(a []int) []int {
+	i, j := 0, len(a)-1
+	for {
+		for i < j && a[i]%2 == 0 {
+			i++
+		}
+		for i < j && a[j]%2 == 1 {
+			j--
+		}
+
+		if i < j {
+			a[i], a[j] = a[j], a[i]
+		} else {
+			break
+		}
+
+	}
+	return a
+}