- 设原始数据规模为n，需要采样的数量为k
- 先选取数据流中的前k个元素，保存在集合A中；
- 从第j（k + 1 <= j <= n）个元素开始，每次先以概率p = k/j选择是否让第j个元素留下。若j被选中，则从A中随机选择一个元素并用该元素j替换它；否则直接淘汰该元素；
- 重复步骤3直到结束，最后集合A中剩下的就是保证随机抽取的k个元素。
算法
-
[1,2,3,4,5,6,7,8,9] 输出 [64,36,16,4]，逆序输出偶数的平方（Reverse String） 344 2
func reverseArray(s[] byte){ lastIndex := len(s) - 1 for i:=0; i -
层序遍历二叉树（Binary Tree Level Order Traversal）102
func levelOrderDFS(root *TreeNode) [][]int { result := [][] int{} levelOrderHelper(root, 0, &result) return result } func levelOrderHelper(node *TreeNode, level int, result *[][]int) { if node == nil { return } if level == len(*result) { *result = append(*result, []int{}) } (*result)[level] = append((*result)[level], node.Val) levelOrderHelper(node.Left, level+1, result) levelOrderHelper(node.Right, level+1, result) } -
链表求和（Add Two Numbers）2
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode { carry := 0 head := new(ListNode) cur := head for l1 != nil || l2 != nil || carry != 0 { n1, n2 := 0, 0 if l1 != nil { n1, l1 = l1.Val, l1.Next } if l2 != nil { n2, l2 = l2.Val, l2.Next } num := n1 + n2 + carry carry = num / 10 cur.Next = &ListNode{Val: num % 10, Next: nil} cur = cur.Next } return head.Next } -
给定一个 0-4 随机数生成器生成 0-6 随机数（Implement Rand10() Using Rand7()）470 2
func rand10() int { index := int(^uint(0) >> 1) for index >= 40 { index = 7 * (rand7() - 1) + (rand7() - 1) } return index % 10 + 1 } -
二叉树的最近公共祖先（Lowest Common Ancestor of a Binary Tree）236 2
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode { if root == nil || root == p || root == q { return root } left := lowestCommonAncestor(root.Left, p, q) right := lowestCommonAncestor(root.Right, p, q) if left != nil && right != nil { return root } if left != nil { return left } return right } -
二叉树最大路径和（Binary Tree Maximum Path Sum）124 2
func maxPathSum(root *TreeNode) int { maxSum := math.MinInt32 maxPathSumHelper(root, &maxSum) return maxSum } func maxPathSumHelper(node *TreeNode, maxSum *int) int { if node == nil { return 0 } left, right := maxPathSumHelper(node.Left, maxSum), maxPathSumHelper(node.Right, maxSum) maxSumEndingAtNode := max(node.Val, node.Val + max(left, right)) *maxSum = max(*maxSum, max(node.Val + left + right, maxSumEndingAtNode)) return maxSumEndingAtNode } func max(x, y int) int { if x > y { return x }; return y } -
链表转二叉树（Convert Sorted List to Binary Search Tree）109
func sortedListToBST(head *ListNode) *TreeNode { return helper(head, nil) } func helper(head *ListNode, end *ListNode)*TreeNode{ if head == end{ return nil } if head.Next == end{ return &TreeNode{Val: head.Val} } mid := findMid(head, end) return &TreeNode{ Val: mid.Val, Left: helper(head, mid), Right: helper(mid.Next, end), } } func findMid(head *ListNode, end *ListNode) *ListNode{ fast := head slow := head for fast != end && fast.Next != end{ fast = fast.Next.Next slow = slow.Next } return slow } -
二叉树删除节点（Delete Node in a BST）450
func FindMin(root *TreeNode) *TreeNode{ for root.Left != nil{ root = root.Left } return root } func deleteNode(root *TreeNode, key int) *TreeNode { if root == nil{ return nil } if key < root.Val{ root.Left = deleteNode(root.Left, key) } else if key > root.Val{ root.Right = deleteNode(root.Right, key) } else{ if root.Right == nil{ return root.Left } else if root.Left == nil{ return root.Right } minNode:= FindMin(root.Right) root.Val = minNode.Val root.Right = deleteNode(root.Right, minNode.Val) } return root } -
奇偶链表（Odd Even Linked List）328
func oddEvenList(head *ListNode) *ListNode { if head == nil { return head } odd := head even := head.Next evenHead := even for even != nil && even.Next != nil { odd.Next = odd.Next.Next even.Next = even.Next.Next odd = odd.Next even = even.Next } odd.Next = evenHead return head }单向链表，奇数位是升序，偶数位是降序，重新排列是降序，时间复杂度O(n)，空间复杂度O(1)。
-
反转链表（Reverse Linked List）206 3
func reverseList(head *ListNode) *ListNode { var prev *ListNode for head != nil { head.Next, prev, head = prev, head, head.Next } return prev } -
合并两个有序链表（Merge Two Sorted Lists）21
func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode { var dummy ListNode tail := &dummy for l1 != nil && l2 != nil { if l1.Val < l2.Val { tail.Next = l1 l1 = l1.Next } else { tail.Next = l2 l2 = l2.Next } tail = tail.Next } if l1 != nil { tail.Next = l1 } if l2 != nil { tail.Next = l2 } return dummy.Next } -
组成N位的数字去掉K位保证数字最小（Remove K Digits）402
func removeKdigits(num string, k int) string { stack := make([]byte, 0) for i := range num { for k > 0 && len(stack) > 0 && stack[len(stack)-1] > num[i] { k-- stack = stack[:len(stack)-1] } stack = append(stack, num[i]) } stack = stack[:len(stack)-k] // Calculate leading zeros var zeros int for i := range stack { if stack[i] != '0' { break } zeros++ } if len(stack) == 0 || zeros == len(stack) { return "0" } return string(stack[zeros:]) } -
下一个更大元素(单调栈)（Next Greater Element II）503
type node struct { index int value int } func nextGreaterElements(nums []int) []int { length := len(nums) nums = append(nums, nums...) var stack []node for i := 0; i < len(nums); i++ { for len(stack) > 0 && stack[len(stack)-1].value < nums[i] { node := stack[len(stack)-1] stack = stack[:len(stack)-1] nums[node.index] = nums[i] } stack = append(stack, node{i, nums[i]}) nums[i] = -1 } return nums[:length] } -
链表环（Linked List Cycle）142 3
func detectCycle(head *ListNode) *ListNode { if head == nil || head.Next == nil { return nil } fast := head slow := head cycle := false for fast.Next != nil && fast.Next.Next != nil { fast = fast.Next.Next slow = slow.Next if fast == slow { cycle = true break } } if !cycle { return nil } for head != slow { head = head.Next slow = slow.Next } return head } -
相交链表（Intersection of Two Linked Lists ）160 3
func getIntersectionNode(headA, headB *ListNode) *ListNode { n1, n2 := headA, headB if headA == nil || headB == nil { return nil } for n1 != n2 { if n1 != nil { n1 = n1.Next } else { n1 = headB } if n2 != nil { n2 = n2.Next } else { n2 = headA } } return n1 } -
二叉树非递归后序遍历（Binary Tree Postorder Traversal ）145
func postorderTraversal(root *TreeNode) []int { if root == nil { return []int{} } traversal := make([]int, 0) stack := make([]*TreeNode, 0) current := root for current != nil || len(stack) > 0 { for current != nil { traversal = append(traversal, current.Val) stack = append(stack, current) current = current.Right } current = stack[len(stack)-1] stack = stack[:len(stack)-1] current = current.Left } reverse(traversal) return traversal } func reverse(nums []int) { for i := 0; i < len(nums)/2; i++ { nums[i], nums[len(nums)-1-i] = nums[len(nums)-1-i], nums[i] } } -
LRU Cache（146） 2
func Constructor(capacity int) LRUCache { m := make(map[int]*CacheNode) c := LRUCache{Cap: capacity, Map: m} return c } func (this *LRUCache) Get(key int) int { found, ok := this.Map[key] if !ok { return -1 } if this.Head == found { return found.Val } if this.Tail == found { this.Tail = found.Prev } if found.Next != nil { found.Next.Prev = found.Prev } if found.Prev != nil { found.Prev.Next = found.Next } this.Head.Prev, found.Next = found, this.Head return found.Val } func (this *LRUCache) Put(key int, value int) { found, ok := this.Map[key] if ok { found.Val = value _ = this.Get(found.Key) return } n := &CacheNode{Key: key, Val: value} if len(this.Map) == 0 { this.Tail = n } else { this.Head.Prev, n.Next = n, this.Head } this.Map[key], this.Head = n, n if this.Cap == this.Len { delete(this.Map, this.Tail.Key) this.Len, this.Tail = this.Len+1, this.Tail.Prev } this.Len++ } type LRUCache struct { Cap int Len int Head *CacheNode Tail *CacheNode Map map[int]*CacheNode } type CacheNode struct { Next *CacheNode Prev *CacheNode Key int Val int } -
Design HashMap（706） 5
type MyHashMap struct { val [1010]list } type list struct { values []node } type node struct { key int value int } func Constructor() MyHashMap { return MyHashMap{val: [1010]list{}} } func (this *MyHashMap) Put(key int, value int) { r := key % 1009 // 如果存在 l := this.val[r].values for i := 0; i < len(l); i++ { if l[i].key == key { l[i].value = value // 如果存在就修改值 return } } this.val[r].values = append(l, node{key: key, value: value}) // 如果不存在加在末尾 } func (this *MyHashMap) Get(key int) int { r := key % 1009 l := this.val[r].values for i := 0; i < len(l); i++ { if l[i].key == key { return l[i].value } } return -1 } func (this *MyHashMap) Remove(key int) { r := key % 1009 l := this.val[r].values for i := 0; i < len(l); i++ { if l[i].key == key { this.val[r].values = append(l[:i], l[i+1:]...) } } } -
快速排序 Quick Sort 4
func QuickSort(values []int) { length := len(values) if length <= 1 { return } // 取第一个元素作为分水岭，i下标初始为1，即分水岭右侧的第一个元素的下标 mid, i := values[0], 1 head, tail := 0, length-1 // 头尾的下标 for head < tail { // 如果头和尾没有相遇，就会一直触发交换 if values[i] > mid { // 如果分水岭右侧的元素大于分水岭，就将右侧的尾部元素和分水岭右侧元素交换 values[i], values[tail] = values[tail], values[i] tail-- // 尾下标左移一位 } else { // 如果分水岭右侧的元素小于等于分水岭，就将分水岭右移一位 values[i], values[head] = values[head], values[i] head++ // 头下标右移一位 i++ // i下标右移一位 } } // 分水岭左右的元素递归做同样处理 QuickSort(values[:head]) QuickSort(values[head+1:]) } -
最长公共子序列（ Longest Common Subsequence）1143
func longestCommonSubsequence(text1 string, text2 string) int { if len(text1) * len(text2) == 0 { return 0 } dp := make([][]int, len(text1)+1) for i := range dp { dp[i] = make([]int, len(text2)+1) } for i, v1 := range text1 { for j, v2 := range text2 { dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]) if v1 == v2 { dp[i+1][j+1] = max(dp[i][j] + 1, dp[i+1][j+1]) } } } return dp[len(text1)][len(text2)] } func max(i, j int) int { if i > j { return i } return j } -
判断BST（Validate Binary Search Tree）98
func isValidBST(root *TreeNode) bool { if root != nil{ for i, v := range []*TreeNode{root.Left, root.Right}{ var q []*TreeNode if v != nil{ q =append(q, v) for len(q) > 0{ v := q[0] q = q[1:] if i==0&&v.Val>=root.Val||i==1&&v.Val<=root.Val{ return false } for _, t :=range []*TreeNode{v.Left, v.Right}{ if t != nil{ q = append(q, t) } } } } } return isValidBST(root.Left)&&isValidBST(root.Right) } return true } -
斐波那且数列，空间复杂度o(1)（Fibonacci Number）509
func fib(N int) int { if N == 0 { return 0 } if N == 1 { return 1 } var a = 0 var b = 1 for i := 2; i <= N; i++ { a, b = b, a+b } return b } -
k个有序链表归并（ Merge k Sorted Lists）23
type minHeap []*ListNode func (h minHeap) Less(i, j int) bool { return h[i].Val < h[j].Val} func (h minHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } func (h minHeap) Len() int { return len(h) } func (h *minHeap) Push(v interface{}) { *h = append(*h, v.(*ListNode))} func (h *minHeap) Pop() interface{} { min := (*h)[len(*h) - 1] *h := (*h)[:len(*h) - 1] return min } func mergeKLists(lists []*ListNode) *ListNode { tmp := minHeap(lists) h := &tmp heap.Init(h) var head, last *ListNode for h.Len() > 0 { v := heap.Pop(h).(*ListNode) if v == nil { continue } if last != nil { last.Next = v } if head == nil { head = v } last = v if v.Next != nil { heap.Push(h, v.Next) } } return head } -
用队列实现栈（Implement Stack using Queues）225
type MyStack struct { enque [] int deque [] int } func Constructor() MyStack { return MyStack{[]int{}, []int{}} } func (this *MyStack) Push(x int) { this.enque = append(this.enque, x) } func (this *MyStack) Pop() int { length := len(this.enque) for i := 0; i < length - 1; i++{ this.deque = append(this.deque, this.enque[0]) this.enque = this.enque[1:] } topEle := this.enque[0] this.enque = this.deque this.deque = nil return topEle } func (this *MyStack) Top() int { topEle := this.Pop() this.enque = append(this.enque, topEle) return topEle } func (this *MyStack) Empty() bool { if len(this.enque) == 0 { return true } return false } -
二叉树路径总和定长（Path Sum III ）437
func pathSum(root *TreeNode, sum int) int { if root == nil { return 0 } return helper(root, sum) + pathSum(root.Left, sum) + pathSum(root.Right, sum) } func helper(root *TreeNode, sum int) int { count := 0 if root == nil { return 0 } if root.Val == sum { count++ } return count + helper(root.Left, sum - root.Val) + helper(root.Right, sum - root.Val) } -
二叉树路径总和定长（Path Sum II ）113
func pathSum(root *TreeNode, sum int) [][]int { var slice [][]int slice = findPath(root, sum, slice, []int(nil)) return slice } func findPath(n *TreeNode, sum int, slice [][]int, stack []int) [][] int { if n == nil { return slice } sum -= n.Val stack = append(stack, n.Val) if sum == 0 && n.Left == nil && n.Right == nil { slice = append(slice, append([]int(nil), stack...)) } slice = findPath(n.Left, sum, slice, stack) slice = findPath(n.Right, sum, slice, stack) return slice } -
二叉树转双向链表（Convert Binary Search Tree to Sorted Doubly Linked List）426 2
func Tree2DoublyList(root *TreeNode) *TreeNode{ if root == nil{ return nill } head, pre := ListNode{}, ListNode{} inOrder(root, pre, head) pre.Right = head head.Left = pre return head } func inOrder(root, pre, head *TreeNode){ if root == nil {return nil} inOrder(root.Left, pre, head) if head == nil{ head = root pre = root }else{ pre.Right = root root.Left = pre pre = root } inOrder(root.Right, pre, head) } -
岛屿的最大面积（Max Area of Island）695 2
func maxAreaOfIsland(grid [][]int) int { var maxArea int for i := 0; i < len(grid); i++ { for j := 0; j < len(grid[0]); j++ { if grid[i][j] == 0 { continue } area := 0 helper(i, j, grid, &area) if area > maxArea { maxArea = area } } } return maxArea } func helper(i, j int, grid [][]int, area *int) { if i < 0 || i == len(grid) || j < 0 || j == len(grid[0]) || grid[i][j] == 0 { return } *area++ grid[i][j] = 0 helper(i+1, j, grid, area) helper(i-1, j, grid, area) helper(i, j+1, grid, area) helper(i, j-1, grid, area) } -
栈排序（Sort Stack By Stack）
func sortStackByStack(s []int) res []int{ while s != nil{ top := s[len(s)-1] s := s[:len(s)-2] while res != nil && res[len(s)-1] > top{ s = append(s, res[len(s)-1]) res = res[:len(s)-2] } res = append(res, top) } } -
Min栈（Min Stack）155
type MinStack struct { stack []int min []int } /** initialize your data structure here. */ func Constructor() MinStack { return MinStack{ stack: make([]int, 0), min: make([]int, 0), } } func (this *MinStack) Push(x int) { this.stack = append(this.stack, x) if len(this.min) == 0 || x <= this.GetMin() { this.min = append(this.min, x) } } func (this *MinStack) Pop() { if this.Top() == this.GetMin() { this.min = this.min[:len(this.min)-1] } this.stack = this.stack[:len(this.stack)-1] } func (this *MinStack) Top() int { return this.stack[len(this.stack)-1] } func (this *MinStack) GetMin() int { return this.min[len(this.min)-1] } -
最大子数组的和（Maximum Subarray）53
func maxSubArray(nums []int) int { var cursum, maxsum int maxsum = math.MinInt32 for _, value := range nums{ cursum += value if cursum > maxsum{ maxsum = cursum } if cursum < 0{ cursum = 0 } } return maxsum } -
交换数字得最大整数（Maximum Swap）670
func maximumSwap(num int) int { var digits []int for num > 0 { digits = append(digits, num%10) num /= 10 } var maxDigit, maxIndex int index1, index2 := -1, -1 for i, digit := range digits { if digit > maxDigit { maxDigit = digit maxIndex = i } else if digit < maxDigit { index1 = i index2 = maxIndex } } if index1 >= 0 { digits[index1], digits[index2] = digits[index2], digits[index1] } var res int for i := len(digits) - 1; i >= 0; i-- { res = res*10 + digits[i] } return res } -
打家劫舍 II（House Robber II）213 3
func rob(nums []int) int { l := len(nums) if l == 0 { return 0 } if l == 1 { return nums[0] } return max(helper(nums[:l-1]), helper(nums[1:])) } func helper(nums []int) int { if len(nums) == 1 { return nums[0] } dp := make([]int, len(nums)) dp[0], dp[1] = nums[0], max(nums[0], nums[1]) for i := 2; i < len(nums); i++ { dp[i] = max(dp[i-2] + nums[i], dp[i-1]) } return dp[len(dp)-1] } func max(a int, b int) int { if a > b { return a } return b } -
LFU Cache 460
type CacheNode struct { key int value int prev *CacheNode next *CacheNode parent *FreqNode } func (n *CacheNode) moveAddOneFreq(key int, value int) *CacheNode { var newFreqNode *FreqNode curFreqNode := n.parent if curFreqNode.next != nil && curFreqNode.next.freq == (curFreqNode.freq + 1) { newFreqNode = curFreqNode.next } else { newFreqNode = NewFreqNode(curFreqNode.freq + 1, curFreqNode, curFreqNode.next) } newCacheNode := &CacheNode{ key: key, value: value, prev: nil, next: newFreqNode.head, parent: newFreqNode, } if newFreqNode.head == nil { newFreqNode.tail = newCacheNode } else { newFreqNode.head.prev = newCacheNode } newFreqNode.head = newCacheNode n.evictNode() return newCacheNode } type FreqNode struct { freq int head *CacheNode tail *CacheNode prev *FreqNode next *FreqNode } func (node *FreqNode) removeFreqNode() { if node.freq == 0 { panic("should not remove the head") } node.prev.next = node.next if node.next != nil { node.next.prev = node.prev } } func NewFreqNode(freq int, prev *FreqNode, next *FreqNode) *FreqNode { nn := &FreqNode{ freq: freq, prev: prev, next: next, } if prev != nil { prev.next = nn } if next != nil { next.prev = nn } return nn } type LFUCache struct { size int capacity int cache map[int]*CacheNode lfuHead *FreqNode } func Constructor(capacity int) LFUCache { zeroFreqHead := &FreqNode{ freq: 0, // head freq is true } return LFUCache{ capacity: capacity, cache: make(map[int]*CacheNode, capacity), lfuHead:zeroFreqHead, } } func (this *LFUCache) Get(key int) int { if found, ok := this.cache[key]; ok { newCacheNode := found.moveAddOneFreq(key, found.value) this.cache[key] = newCacheNode return found.value } else { return -1 } } func (this *LFUCache) Put(key int, value int) { if this.capacity == 0 { return } if found, ok := this.cache[key]; ok { newCacheNode := found.moveAddOneFreq(key, value) this.cache[key] = newCacheNode } else { if this.size >= this.capacity { lfuNode := this.lfuHead.next.tail delete(this.cache, lfuNode.key) lfuNode.evictNode() } else { this.size++ } var oneFreqNode *FreqNode if this.lfuHead.next != nil && this.lfuHead.next.freq == 1 { oneFreqNode = this.lfuHead.next } else { oneFreqNode = NewFreqNode(1, this.lfuHead, this.lfuHead.next) } newCacheNode := &CacheNode{ key: key, value: value, prev: nil, next: oneFreqNode.head, parent: oneFreqNode, } this.cache[key] = newCacheNode if oneFreqNode.head == nil { oneFreqNode.tail = newCacheNode } else { oneFreqNode.head.prev = newCacheNode } oneFreqNode.head = newCacheNode } } func (node *CacheNode) evictNode() { // remove the cache node from the linkedList // remove the freqNode(parent) if it is empty // do nothing to the map curFreqNode := node.parent if node.prev != nil { node.prev.next = node.next } else { curFreqNode.head = node.next } if node.next != nil { node.next.prev = node.prev } else { curFreqNode.tail = node.prev } if curFreqNode.head == nil { curFreqNode.removeFreqNode() } } -
链表排序（Sort List）148
func sortList(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } slow, fast := head, head.Next for fast.Next != nil && fast.Next.Next != nil { slow = slow.Next fast = fast.Next.Next } rightHead := slow.Next slow.Next = nil return merge(sortList(head), sortList(rightHead)) } func merge(list1 *ListNode, list2 *ListNode) *ListNode { result := &ListNode{Val: 0} current := result for list1 != nil && list2 != nil { if list1.Val < list2.Val { current.Next = list1 list1 = list1.Next } else { current.Next = list2 list2 = list2.Next } current = current.Next } if list1 != nil { current.Next = list1 } if list2 != nil { current.Next = list2 } return result.Next } -
数组中超过一半的数字（Majority Element）169 3
func majorityElement(nums []int) int { m := make(map[int] int) for _, v := range nums{ m[v]++ if m[v] > len(nums) / 2 { return v } } return 0 } -
每K个一组反转列表（Reverse Nodes in k-Group）25 2
func reverseKGroup(head *ListNode, k int) *ListNode { if head == nil || head.Next == nil || k < 2 { return head } curr := head count := 0 for curr != nil && count != k { curr = curr.Next count++ } if count == k { curr = reverseKGroup(curr, k) for count > 0 { tmp := head.Next head.Next = curr curr = head head = tmp count-- } head = curr } return head } -
对称二叉树（Symmetric Tree）101
func isSymmetric(root *TreeNode) bool { if root == nil{ return true } return ish(root.Left, root.Right) } func ish(l, r *TreeNode) bool{ if l == nil || r == nil{ return l == r } if l.Val != r.Val { return false } return ish(l.Left, r.Right) && ish(l.Right, r.Left) } -
字符串解码（Decode String）394 2
func decodeString(s string) string { stackNums := make([]int, 0) stackStr := make([]string, 0) var res string var num int for i := 0; i < len(s); i++ { switch { case s[i] >= '0' && s[i] <= '9': num = 10*num + int(s[i]) - '0' case s[i] == '[': stackNums = append(stackNums, num) num = 0 stackStr = append(stackStr, res) res = "" case s[i] == ']': tmp := stackStr[len(stackStr)-1] stackStr = stackStr[:len(stackStr)-1] count := stackNums[len(stackNums)-1] stackNums = stackNums[:len(stackNums)-1] res = tmp + strings.Repeat(res, count) default: res += string(s[i]) } } return res } -
区间合并（Merge Intervals）2
func merge(intervals [][]int) [][]int { if len(intervals) == 0 { return [][]int{} } merged := make([][]int, 0, len(intervals)) sort.Slice(intervals, func(i, j int) bool { return intervals[i][0] < intervals[j][0] }) current := intervals[0] for i := 1; i < len(intervals); i++ { if intervals[i][0] > current[1] { merged = append(merged, current) current = intervals[i] } else if intervals[i][1] > current[1] { current[1] = intervals[i][1] } } merged = append(merged, current) return merged } -
数组序号转换（Rank Transform of an Array）1331
type Ints []int func (arr Ints) Len() int { return len(arr) } func (arr Ints) Swap(i, j int) { arr[i], arr[j] = arr[j], arr[i] } func (arr Ints) Less(i, j int) bool { return arr[i] < arr[j] } func arrayRankTransform(arr []int) []int { var m map[int][]int = make(map[int][]int) for i, v := range arr { m[v] = append(m[v], i) } sort.Sort(Ints(arr)) // fmt.Println("after sorted", arr) var res []int = make([]int, len(arr)) var seq int = 1 for _, v := range arr { if _, ok := m[v]; ok == true { for _, v1 := range m[v] { res[v1] = seq } seq++ delete(m, v) } } return res } -
数组中第K个大的元素（Kth Largest Element in an Array）215 2
func findKthLargest(nums []int, k int) int { nlen := len(nums) targetPos := nlen - k start, end := 0, nlen-1 for { pivotIndex := partition(nums, start, end) if pivotIndex == targetPos { return nums[pivotIndex] } else if pivotIndex < targetPos { start = pivotIndex + 1 } else { end = pivotIndex - 1 } } } func partition(nums []int, start, end int) int { pivot := nums[start] left, right := start+1, end for left <= right { for left <= right && nums[left] <= pivot { left++ } for left <= right && nums[right] > pivot { right-- } if left <= right { nums[left], nums[right] = nums[right], nums[left] } } nums[start], nums[right] = nums[right], nums[start] return right } -
反转数组中的最小值（Find Minimum in Rotated Sorted Array）153 3
func findMin(nums []int) int { left, right := 0, len(nums)-1 for left < right { mid := (left + right) / 2 if nums[mid] > nums[right] { left = mid + 1 } else { right = mid } } return nums[left] } -
平衡二叉树（Balanced Binary Tree）110 2
func isBalanced(root *TreeNode) bool { return maxDepth(root) != -1 } func maxDepth(root *TreeNode) int { if root == nil { return 0 } left := maxDepth(root.Left) right := maxDepth(root.Right) if left == -1 || right == -1 || left-right > 1 || right-left > 1 { return -1 } return max(left, right) + 1 } func max(a, b int) int { if a > b { return a } return b } -
括号匹配（Longest Valid Parentheses）32
func longestValidParentheses(s string) int { var result int stack := []int{-1} for i := range s { if len(stack) > 1 && s[i] == ')' && s[stack[len(stack)-1]] == '(' { stack = stack[:len(stack)-1] if i-stack[len(stack)-1] > result { result = i - stack[len(stack)-1] } } else { stack = append(stack, i) } } return result } -
二叉树右视图（Binary Tree Right Side View）199
func rightSideView(root *TreeNode) []int { result := make([] int, 0) rightView(root, &result, 0) return result } func rightView(cur *TreeNode, result *[]int, curDepth int) { if cur == nil { return } if curDepth == len(*result) { *result = append(*result, cur.Val) } rightView(cur.Right, result, curDepth+1) rightView(cur.Left, result, curDepth+1) } -
首个缺失正数（First Missing Positive）41
func firstMissingPositive(nums []int) int { length := len(nums) for i := 0; i < length; i++ { if nums[i] <= 0 || nums[i] > length { nums[i] = 0 } else if nums[i] == i+1 { continue } else if nums[i] == nums[nums[i]-1] { nums[i] = 0 } else if nums[i] != nums[nums[i]-1] { nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1] i-- } } for i, v := range nums { if v == 0 { return i+1 } } return length+1 } -
只出现一次的数字（Single Number）136
func singleNumber(nums []int) int { var result int for i := range nums { result ^= nums[i] } return result } -
最长无重复子串（Longest Substring Without Repeating Characters）3
func maxInt(a, b int) int { if a > b { return a } return b } func lengthOfLongestSubstring(s string) int { maxLen, start := 0, 0 table := [128]int{} for i, _ := range table { table[i] = -1 } for i, c := range s { if table[c] >= start { start = table[c] + 1 } table[c] = i maxLen = maxInt(maxLen, i - start + 1) } return maxLen } -
组合之和（Combination Sum）39
func combinationSum(candidates []int, target int) [][]int { result := make([][]int, 0) backtracking([]int{}, candidates, 0, target, &result) return result } func backtracking(subset, candidates []int, sum, target int, result *[][]int) { if sum == target { *result = append(*result, subset) return } else if sum > target { return } for i := range candidates { subsetCopy := make([]int, 0, len(subset)+1) subsetCopy = append(subsetCopy, subset...) backtracking(append(subsetCopy, candidates[i]), candidates[i:], sum+candidates[i], target, result) } } -
顺时针打印矩阵（Spiral Matrix）54
func spiralOrder(matrix [][]int) []int { if len(matrix) == 0 || len(matrix[0]) == 0 { return []int{} } var res []int top, bottom, left, right := 0, len(matrix) - 1, 0, len(matrix[0]) - 1 point := []int{0, 0} for { for i := point[1]; i <= right; i++{ res = append(res, matrix[point[0]][i]) } if point[0] >= bottom { break } top, point[0], point[1] = top + 1, point[0] + 1, right for i := point[0]; i <= bottom; i++{ res = append(res, matrix[i][point[1]]) } if point[1] <= left { break } right, point[0], point[1] = right - 1, bottom, point[1] -1 for i := point[1]; i >= left; i--{ res = append(res, matrix[point[0]][i]) } if point[0] <= top { break } bottom, point[0], point[1] = bottom - 1, point[0] - 1, left for i := point[0]; i >= top; i--{ res = append(res, matrix[i][point[1]]) } if point[1] >= right{ break } left, point[0], point[1] = left + 1, top, point[1] + 1 } return res } -
36进制加法
func Add(str1 string, str2 string) string { List36 := []string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"} i := len(str1) - 1 j := len(str2) - 1 var sum string var tem int //进位 for i >= 0 && j >= 0 { s := GetInt(str1[i]) + GetInt(str2[j]) + tem if s >= 36 { tem = 1 sum = List36[s%36]+sum } else { tem = 0 sum = List36[s]+sum } i-- j-- } for i >= 0 { s:= GetInt(str1[i])+tem if s>=36{ tem = 1 sum = List36[s%36]+sum }else { tem = 0 sum = List36[s]+sum } i-- } for j >= 0 { s:= GetInt(str2[i])+tem if s>=36{ tem = 1 sum = List36[s%36]+sum }else { tem = 0 sum = List36[s]+sum } j-- } if tem!=0{ sum="1"+sum } return sum } //将'0'-'9'映射到数字0-9，将'a'-'z'映射到数字10-35 func GetInt(a uint8) int { if a-'0' > 0 && a <= '9' { return int(a - '0') } else { return int(a-'A') + 10 } } -
Sqrt(x) 69
func mySqrt(x int) int { for left, right := 0, x; ; { mid := left + (right-left)/2 if mid*mid > x { right = mid - 1 } else if (mid+1)*(mid+1) > x { return mid } else { left = mid + 1 } } } -
快速幂（Pow(x, n)）50
func myPow(x float64, n int) float64 { if n < 0 { x, n = 1/x, -n } result := 1.0 for n > 0 { if n&1 == 1 { result *= x } x, n = x*x, n>>1 } return result } -
抛掷硬币（Toss Strange Coins）1230
func probabilityOfHeads(prob []float64, target int) float64 { dp := make([]float64, len(prob) + 1) dp[0] = 1.0 for i := 0; i < len(prob); i++ { for k := target; k >= 0; k-- { if k > 0 { dp[k] = dp[k - 1] * prob[i] + dp[k] * (1 - prob[i]) } else { dp[k] = dp[k] * (1 - prob[i]) } } } return dp[target] } -
按奇偶排序数组（Sort Array By Parity）922
func sortArrayByParityII(A []int) []int { i := 1 for j:=0;j -
N叉树层序遍历（N-ary Tree Level Order Traversal）429
func levelOrder(root *Node) [][]int { res := [][]int{} helper(root, 0, &res) return res } func helper(root *Node, level int, res *[][]int){ if root == nil{ return } for _, v := range root.Children{ helper(v, level+1, res) } for len(*res) <= level{ *res = append(*res, []int{}) } (*res)[level] = append((*res)[level], root.Val) } -
最小覆盖子串（Minimum Window Substring ）76
func minWindow(s string, t string) string { requirements := make(map[byte]int) for i := range t { requirements[t[i]]++ } apperances := make(map[byte]int) counter := len(t) minLen := len(s) + 1 resLeft, resRight := 0, 0 for left, right := 0, 0; right < len(s); { lch, rch := s[left], s[right] if _, ok := requirements[rch]; ok { apperances[rch]++ if apperances[rch] <= requirements[rch] && counter != 0 { counter-- } } if counter == 0 { for { if _, ok := apperances[lch]; !ok || apperances[lch] > requirements[lch] { if apperances[lch] > requirements[lch] { apperances[lch]-- } left++ lch = s[left] } else { break } } if right-left+1 < minLen { resLeft, resRight = left, right+1 minLen = right - left + 1 } } right++ } if resLeft == 0 && resRight == 0 { return "" } return s[resLeft:resRight] } -
数组中最长的山（Longest Mountain in Array）845
type direction int const ( UP direction = iota DOWN FLAT ) func max(a, b int) int { if a > b { return a } return b } func longestMountain(A []int) int { N := len(A) if N < 3 { return 0 } longest := 0 i := 1 for ; i < N && A[i] <= A[i - 1]; i++ {;} direc, upStep, downStep := UP, 1, 0 for i++; i < N; i++ { if direc == UP { if A[i] > A[i - 1] { upStep++ } else if A[i] < A[i - 1] { direc, upStep, downStep = DOWN, upStep + 1, 1 } else { direc, upStep, downStep = FLAT, 0, 0 } } else if direc == FLAT { for ; i < N && A[i] <= A[i - 1]; i++ {;} direc, upStep, downStep = UP, 1, 0 } else { if A[i] > A[i - 1] { longest = max(longest, upStep + downStep) direc, upStep, downStep = UP, 1, 0 } else if A[i] < A[i - 1] { downStep++ } else { longest = max(longest, upStep + downStep) direc, upStep, downStep = FLAT, 0, 0 } } } if direc == DOWN { longest = max(longest, upStep + downStep) } return longest } -
删除数组中相邻重复数（Remove All Adjacent Duplicates in String）1047
func removeDuplicates(S string) string { stack := []byte{} for i := 0; i < len(S); i++ { if len(stack) != 0 && stack[len(stack)-1] == S[i] { stack = stack[:len(stack)-1] } else { stack = append(stack, S[i]) } } return string(stack) } -
给表达式添加运算符（Expression Add Operators）282
func addOperators(num string, target int) []string { ans := make([]string, 0) currStr := "" backTrack(num, 0, target, currStr, &ans) return ans } func backTrack(num string, idx ,target int, currStr string, ans *[]string) { if idx == len(num) { if len(currStr) > 0 && isNumeric(currStr[len(currStr)-1]) { if isEquationCorrect(currStr, target) { *ans = append(*ans, currStr) } } return } if len(currStr) >0 && isNumeric(currStr[len(currStr)-1]) { backTrack(num, idx, target, currStr+"*", ans) backTrack(num, idx, target, currStr+"+", ans) backTrack(num, idx, target, currStr+"-", ans) } backTrack(num, idx+1, target, currStr+string(num[idx]), ans) } func isNumeric(b byte) bool { if b >= 48 && b <= 57 { return true} return false } func isEquationCorrect(eq string, target int) bool { stack := make([]string, 0) idx := 0 for idx < len(eq) { if eq[idx] == '-' || eq[idx] == '+' { stack = append(stack, string(eq[idx])) idx++ continue } else if eq[idx] >= 48 && eq[idx] <= 57 { prev := idx for idx < len(eq) && eq[idx] >= 48 && eq[idx] <= 57 { idx++ } if len(string(eq[prev:idx])) > 1 && string(eq[prev:idx])[0] == 48 { return false } stack = append(stack, string(eq[prev:idx])) continue } else if eq[idx] == '*' { prevNum, _ := strconv.Atoi(stack[len(stack)-1]) stack = stack[:len(stack)-1] idx++ prev := idx for idx < len(eq) && eq[idx] >= 48 && eq[idx] <= 57 { idx++ } if len(string(eq[prev:idx])) > 1 && string(eq[prev:idx])[0] == 48 { return false } num,_ := strconv.Atoi(eq[prev:idx]) newNum := num*prevNum stack = append(stack, strconv.Itoa(newNum)) } } ans := 0 sign := 1 for _, val := range stack { if val == "-" { sign = -1 } else if val != "+" && val != "-" { num,_ := strconv.Atoi(val) ans += sign*num sign = 1 } } return ans == target } -
过桥
func bridge(v []int){ length := len(v) sort.Ints(v) dp := make([]int, length) dp[0], dp[1] = v[0], v[1] for i:=2; i -
删除注释（Remove Comments）722
func removeComments(source []string) []string { inblock := false var result []string var arr []string for i:=0;i -
买卖股票的最佳时机（Best Time to Buy and Sell Stock） 121
func maxProfit(prices []int) int { if len(prices) < 2 { return 0 } var profit int min := prices[0] for i := 1; i < len(prices); i++ { if prices[i]-min > profit { profit = prices[i] - min } if prices[i] < min { min = prices[i] } } return profit } -
搜索二维矩阵（Search a 2D Matrix II）240
func searchMatrix(matrix [][]int, target int) bool { if matrix == nil || len(matrix) == 0 || len(matrix[0]) == 0 { return false } row, col := 0, len(matrix[0])-1 for row < len(matrix) && col >= 0 { val := matrix[row][col] if val > target { col-- } else if val < target { row++ } else { return true } } return false } -
爱吃香蕉的珂珂（Koko Eating Bananas） 875
func minEatingSpeed(piles []int, H int) int { left, right := 1, math.MaxInt32 for left <= right { mid := left + (right-left)/2 if minEatingSpeedHelper(piles, H, mid) { right = mid - 1 } else { left = mid + 1 } } return left } func minEatingSpeedHelper(piles []int, H int, K int) bool { for i := 0; i < len(piles); i++ { H -= ((piles[i]-1)/K + 1) if H < 0 { return false } } return true } -
字符串实现减法（ Subtract two integers）
func subtract(num1, num2 string)int{ if len(num1) < len(num2){ subtract(num2, num1) return } if len(num1) == len(num2){ for i:=0; i -
压平二维向量（Flatten 2D Vector）251
type Vector2D struct { v [][]int r, c int } func Constructor(v [][]int) Vector2D { return Vector2D{v, 0, 0 } func (this *Vector2D) Next() int { this.HasNext() v := this.v[this.r][this.c] this.c++ return v } func (this *Vector2D) HasNext() bool { for this.r < len(this.v) { if this.r < len(this.v) && this.c < len(this.v[this.r]) { return true } if this.c == len(this.v[this.r]) { this.r++ this.c = 0 } else { this.c++ } } return false } -
硬币找零（Coin Change）322
func coinChange(coins []int, amount int) int { dp := make([]int, amount+1) for i := 1; i <= amount; i++ { min := -1 for _, coin := range coins { if i < coin || dp[i-coin] == -1 { continue } if min == -1 || dp[i-coin]+1 < min { min = dp[i-coin] + 1 } } dp[i] = min } return dp[amount] } -
取子游戏（Nim Game）292
func canWinNim(n int) bool { return n%4 != 0 } -
下一个排列（Next Permutation）31
func nextPermutation(nums []int) { if len(nums) < 2 { return } var idx = len(nums) - 1 for idx > 0 { if nums[idx-1] < nums[idx] { break } idx-- } reverseSort(nums, idx, len(nums)-1) if idx == 0 { return } for i := idx; i < len(nums); i++ { if nums[i] > nums[idx-1] { nums[idx-1], nums[i] = nums[i], nums[idx-1] return } } } func reverseSort(nums []int, start int, end int) { for i, j := start, end; i < end+(start-end)/2; i, j = i+1, j-1 { nums[i], nums[j] = nums[j], nums[i] } }
海量数据
- 分而治之/hash映射 + hash统计 + 堆/快速/归并排序
- 双层桶划分
- Bloom filter/Bitmap
- Trie树/数据库/倒排索引
- 外排序
- 分布式处理之Hadoop/Mapreduce
-
10亿个数字，取最小的100个数 heapSort、partition、（时间、空间复杂度）5
数据全部排序，然后在排序后的集合中进行查找，最快的排序算法的时间复杂度一般为O（nlogn），如快速排序。但是在32位的机器上，每个float类型占4个字节，1亿个浮点数就要占用400MB的存储空间。
局部淘汰法，用一个容器保存前10000个数，然后将剩余的所有数字——与容器内的最小数字相比，如果某一后续元素比容器内最小数字大，则删掉容器内最小元素，并将该元素插入容器，最后遍历完这1亿个数，得到的结果容器中保存的数即为最终结果了。此时的时间复杂度为O（n+m^2），其中m为容器的大小，即10000。
分治法，将1亿个数据分成100份，每份100万个数据，找到每份数据中最大的10000个，最后在剩下的100*10000个数据里面找出最大的10000个。
Hash法。如果这1亿个书里面有很多重复的数，先通过Hash法，把这1亿个数字去重复，缩小运算空间，然后通过分治法或最小堆法查找最大的10000个数。
最小堆。首先读入前10000个数来创建大小为10000的最小堆，建堆的时间复杂度为O（mlogm）（m为数组的大小即为10000），然后遍历后续的数字，并于堆顶（最小）该算法的时间复杂度为O（nmlogm），空间复杂度是10000（常数）。
func heapSort(data []int) { for i := (len(data) - 1) / 2; i >= 0; i-- { // create heap siftDown(data, i, len(data)) } for i := len(data) - 1; i >= 0; i-- { // sort data[0], data[i] = data[i], data[0] siftDown(data, 0, i) } } func siftDown(data []int, low, high int) { root := low for { child := 2*root + 1 if child >= high { break } if child+1 < high && data[child] < data[child+1] { child++ } if data[root] >= data[child] { break } data[root], data[child] = data[child], data[root] root = child } }