剑指offer_Go版

剑指offer_Go版

前言

要工作了 大概率是写Go

我记得今年3 4 月份就想着搞个go版剑指offer一直拖到现在

仅仅go语法基础 还是几个月前学的 现在回顾下 2020/11/13留

2020/11/16留 更新差不多一半了

2020/11/17留 快完结了 准备开高性能sql和进阶go

2020/11/18留 写不动了弃坑 空了一些题 有些不能交go 有些太过偏门题跳过了 略过的不多

剑指 Offer 03. 数组中重复的数字

func findRepeatNumber(nums []int) int {
    for i, num := range nums {
        if i == num {
            continue
        }
        if nums[num] == num {
            return num
        }
        nums[num], nums[i] = nums[i], nums[num]
    }
    return -1
}

剑指 Offer 05. 替换空格

func replaceSpace(s string) string {
    var res string
    for key, val := range s{
        if val == ' ' {
            res += "%20"
        } else {
            res += s[key:key + 1]
        }
    }
    return res
}

剑指 Offer 06. 从尾到头打印链表

递归

func reversePrint(head *ListNode) []int {
    if head == nil {
        return nil
    } else {
        return append(reversePrint(head.Next), head.Val)
    }
}

迭代

func reversePrint(head *ListNode) []int {
    var res []int
    for ; head != nil; head = head.Next {
        res = append(res, head.Val)
    }
    for i, l := 0, len(res); i < l / 2; i = i + 1{
        res[i], res[l - i - 1] = res[l - i - 1], res[i]
    }
    return res
}

剑指 Offer 07. 重建二叉树

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func buildTree(preorder []int, inorder []int) *TreeNode {
    if len(preorder) == 0 {
        return nil
    }
    idx := 0
    for i := range inorder {
        if inorder[i] == preorder[0] {
            idx = i
            break
        }
    }
    root := &TreeNode{Val : preorder[0]}
    root.Left = buildTree(preorder[1 : idx + 1], inorder[ : idx])
    root.Right = buildTree(preorder[idx + 1 : ], inorder[idx + 1 : ])
    return root
}

剑指 Offer 09. 用两个栈实现队列

type CQueue struct {
    s1, s2 *list.List
}

func Constructor() CQueue {
    return CQueue {
        s1:list.New(), s2:list.New(),
    }
}

func (this *CQueue) AppendTail(value int)  {
    this.s1.PushBack(value)
}

func (this *CQueue) DeleteHead() int {
    if this.s2.Len() == 0 { // s1 元素扔入2中
        for this.s1.Len() > 0 {
            this.s2.PushBack(this.s1.Remove(this.s1.Back()))
        }
    }
    if this.s2.Len() > 0 {
        tmp := this.s2.Back()
        this.s2.Remove(tmp)
        return tmp.Value.(int)
    }
    return -1
}

/**
 * Your CQueue object will be instantiated and called as such:
 * obj := Constructor();
 * obj.AppendTail(value);
 * param_2 := obj.DeleteHead();
 */

剑指 Offer 10- I. 斐波那契数列

可以记忆化搜 防超时 看了下题解都没这样写的

var dp [105]int
func fib(n int) int {
    if dp[n] != 0 {return dp[n]}
    if n < 2 {
        return n
    } else {
        dp[n] = (fib(n - 1) + fib(n - 2)) % (1e9+7)
        return dp[n]
    }
}

剑指 Offer 10- II. 青蛙跳台阶问题

func numWays(n int) int {
    return fib(n)
}

var dp [105]int
func fib(n int) int {
    if dp[n] != 0 {return dp[n]}
    if n <= 1 {
        return 1
    } else {
        dp[n] = (fib(n - 1) + fib(n - 2)) % (1e9+7)
        return dp[n]
    }
}

剑指 Offer 11. 旋转数组的最小数字

func minArray(numbers []int) int {
    l := 0
    r := len(numbers) - 1
    for l < r {
        mid := (l + r) / 2
        if(numbers[mid] < numbers[r]) {
            r = mid
        } else if(numbers[mid] == numbers[r]) {
            r = r - 1
        } else {
            l = mid + 1
        }
    }
    return numbers[l]
}

剑指 Offer 12. 矩阵中的路径

func exist(board [][]byte, word string) bool {
    n := len(board)
    m := len(board[0])
    l := len(word)
    for i := 0; i < n; i ++ {
        for j := 0; j < m; j ++ {
            if(dfs(n, m, board, l, word, i, j, 0)) {
                return true
            }
        }
    }
    return false
}

func dfs(n int, m int, board [][]byte, l int,word string, x int, y int, p int) bool { 
    if(p == l) {
        return true
    }
    if x < 0 || y < 0 || x >= n || y >= m {
        return false
    }
    if(board[x][y] == word[p]) {
        t := board[x][y]
        board[x][y] = ' '
        res := dfs(n, m, board, l, word, x + 1, y, p + 1) || dfs(n, m, board, l, word, x - 1, y, p + 1) ||
               dfs(n, m, board, l, word, x, y - 1, p + 1) || dfs(n, m, board, l, word, x, y + 1, p + 1)
        board[x][y] = t
        return res
    } else {
        return false
    }
}

剑指 Offer 13. 机器人的运动范围

开始在语法上蛋疼

func chk(x int, y int, m int, n int) bool {
    return x < 0 || y < 0 || x >= m || y >= n
}

func BitSum(x int) int {
    res := 0
    for x > 0 {
        res += x % 10
        x /= 10
    }
    return res
}

type P struct{
    A, B int
}

func movingCount(m int, n int, k int) int {
    res := 0
    que := list.New()
    que.PushBack(&P{0, 0})
    var vis [105][105]bool
    for que.Len() > 0 {
        p := que.Front()
        que.Remove(p)
        x := p.Value.(*P).A
        y := p.Value.(*P).B
        if chk(x, y, m, n) || vis[x][y] == true || BitSum(x) + BitSum(y) > k { continue }
        vis[x][y] = true
        res ++
        que.PushBack(&P{x + 1, y})
        que.PushBack(&P{x, y + 1})
    }
    return res
}

剑指 Offer 14- I. 剪绳子

最优： 3 把绳子尽可能切为多个长度为 3 的片段
次优： 2 若最后一段绳子长度为 2 ；则保留，不再拆为 1+1
最差： 1 若最后一段绳子长度为 1 ；则应把一份 3 + 1 替换为 2 + 2
2 + 2 == 1 + 3 && 2 * 2 > 1 * 3

func cuttingRope(n int) int {
    if n <= 3 {
        return n - 1
    }
    a, b := n / 3, n % 3
    if b == 0 {
        return int(math.Pow(3, float64(a)))
    } else if b == 1 {
        return int(math.Pow(3, float64(a - 1)) * 4)
    } else {
        return int(math.Pow(3, float64(a)) * 2)
    }
}

剑指 Offer 14- II. 剪绳子 II

注意取模

func q_pow(a, b int) int {
    res := 1
    mod := int(1e9 + 7)
    for b != 0 {
        if b & 1 == 1 {
            res = res * a % mod
        }
        a = a * a % mod
        b >>= 1
    }
    return res
}

func cuttingRope(n int) int {
    mod := int(1e9 + 7)
    if n <= 3 {
        return n - 1
    }
    a, b := n / 3, n % 3
    if b == 0 {
        return int(q_pow(3, a))
    } else if b == 1 {
        return int(q_pow(3, a - 1) * 4) % mod
    } else {
        return int(q_pow(3, a) * 2) % mod
    }
}

剑指 Offer 15. 二进制中1的个数

func hammingWeight(num uint32) int {
    res := 0
    for num > 0 {
        if num & 1 == 1 { res ++ }
        num >>= 1
    }
    return res
}

剑指 Offer 16. 数值的整数次方

func q_pow(a float64, b int) float64 {
    res := 1.0
    if b < 0 {
        a = 1.0 / a
        b = -b
    }
    for b != 0 {
        if b & 1 == 1 {
            res = res * a
        }
        a = a * a
        b >>= 1
    }
    return res
}

func myPow(x float64, n int) float64 {
    return q_pow(x, n)
}

剑指 Offer 19. 正则表达式匹配

var dp [][]int

func isMatch(s string, p string) bool {
    dp = make([][]int, len(s) + 1)
    for i := 0; i < len(dp); i ++ {
        dp[i] = make([]int, len(p) + 1)
        for j := 0; j < len(p) + 1; j ++{
            dp[i][j] = -1;
        }
    }
    return sol(s, p, 0, 0)
}

func sol(s string, p string, x int, y int) bool {
    if dp[x][y] != -1 { return dp[x][y] == 1 }
    if y == len(p) { 
        if x == len(s) {
            dp[x][y] = 1
            return true
        } else {
            dp[x][y] = 0
            return false
        }
    }
    match := x < len(s) && (s[x] == p[y] || p[y] == '.')
    var tmp bool
    if y + 1 < len(p) && p[y + 1] == '*' {
        tmp = ( (match && sol(s, p, x + 1, y) ) || sol(s, p, x, y + 2))
    } else {
        tmp = match && sol(s, p , x + 1, y + 1)
    }
    return tmp
}

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

func exchange(nums []int) []int {
    st, ed := 0, len(nums) - 1
    for st < ed {
        for st < ed && nums[st] % 2 == 1 { st ++ }
        for st < ed && nums[ed] % 2 == 0 { ed -- }
        nums[st], nums[ed] = nums[ed], nums[st]
        st ++
        ed --
    }
    return nums
}

剑指 Offer 22. 链表中倒数第k个节点

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getKthFromEnd(head *ListNode, k int) *ListNode {
    f := head
    p := 0
    for f != nil && p < k {
        f = f.Next
        p ++
    }
    for f != nil {
        f = f.Next
        head = head.Next
    }
    return head
}

剑指 Offer 25. 合并两个排序的链表

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    p1, p2 := l1, l2
    dummy := ListNode{-1, nil}
    p := &dummy
    for p1 != nil && p2 != nil {
        if p1.Val < p2.Val { 
            p.Next = p1
            p1 = p1.Next
        } else { 
            p.Next = p2
            p2 = p2.Next
        }
        p = p.Next
    }
    if p1 != nil { 
        p.Next = p1 
    } else { p.Next = p2 }
    return dummy.Next
}

剑指 Offer 26. 树的子结构

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSubStructure(A *TreeNode, B *TreeNode) bool {
    return A != nil && B != nil && (dfs(A, B) || isSubStructure(A.Left, B) || isSubStructure(A.Right, B))
}

func dfs(A *TreeNode, B *TreeNode) bool {
    if B == nil { return true }
    if A == nil || A.Val != B.Val { return false }
    return dfs(A.Left, B.Left) && dfs(A.Right, B.Right)
}

剑指 Offer 27. 二叉树的镜像

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func mirrorTree(root *TreeNode) *TreeNode {
    if root == nil { return nil }
    root.Left, root.Right = root.Right, root.Left
    mirrorTree(root.Left)
    mirrorTree(root.Right)
    return root
}

剑指 Offer 28. 对称的二叉树

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
    return dfs(root, root)
}

func dfs(t1 *TreeNode, t2 *TreeNode) bool {
    if t1 == nil && t2 == nil { return true }
    if t1 == nil || t2 == nil || t1.Val != t2.Val { return false }
    return dfs(t1.Left, t2.Right) && dfs(t1.Right, t2.Left)
}

剑指 Offer 29. 顺时针打印矩阵

func spiralOrder(matrix [][]int) []int {
    if len(matrix) == 0 { return []int{} }
    rows, cols := len(matrix), len(matrix[0])

    vis := make([][]bool, rows)
    for i := 0; i < rows; i ++ {
        vis[i] = make([]bool, cols)
    }

    tot := rows * cols
    res := make([]int, tot)
    cxy := [][]int{[]int{0, 1}, []int{1, 0}, []int{0, -1}, []int{-1, 0}}
    c := 0

    for i, x, y := 0, 0, 0; i < tot; i ++ {
        res[i] = matrix[x][y]
        vis[x][y] = true
        nx := x + cxy[c][0]
        ny := y + cxy[c][1]
        if(nx < 0 || ny < 0 || nx >= rows || ny >=cols || vis[nx][ny]) {
            c = (c + 1) % 4
        }
        x = x + cxy[c][0]
        y = y + cxy[c][1] 
    }
    return res
}

剑指 Offer 30. 包含min函数的栈

type MinStack struct {
    min_stack, stack *list.List
}
/** initialize your data structure here. */
func Constructor() MinStack {
    return MinStack {
        min_stack:list.New(),
        stack:list.New(),
    }
}

func Min(x, y int) int {
    if x < y {
        return x
    }
    return y
}

func (this *MinStack) Push(x int)  {
    this.stack.PushBack(x)
    if this.min_stack.Len() == 0 {
        this.min_stack.PushBack(x)
    } else {
        this.min_stack.PushBack(Min(this.min_stack.Back().Value.(int), x))
    }
}


func (this *MinStack) Pop()  {
    this.stack.Remove(this.stack.Back())
    this.min_stack.Remove(this.min_stack.Back())
}


func (this *MinStack) Top() int {
    return this.stack.Back().Value.(int)
}

func (this *MinStack) Min() int {
    return this.min_stack.Back().Value.(int)
}

/**
 * Your MinStack object will be instantiated and called as such:
 * obj := Constructor();
 * obj.Push(x);
 * obj.Pop();
 * param_3 := obj.Top();
 * param_4 := obj.Min();
 */

剑指 Offer 31. 栈的压入、弹出序列

func validateStackSequences(pushed []int, popped []int) bool {
    s := new(list.List)
    i := 0
    for _, num := range(pushed) {
        s.PushBack(num)
        for s.Len() > 0 && s.Back().Value.(int) == popped[i] {
            s.Remove(s.Back())
            i ++
        }
    }
    return s.Len() == 0
}

剑指 Offer 32 - I. 从上到下打印二叉树

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) []int {
    if root == nil { return []int{} }
    var res []int
    queue := list.New()
    queue.PushBack(root)
    for queue.Len() > 0 {
        node := queue.Front().Value.(*TreeNode)
        queue.Remove(queue.Front())
        res = append(res, node.Val)
        if node.Left != nil { queue.PushBack(node.Left) }
        if node.Right != nil { queue.PushBack(node.Right) }
    }
    return res
}

剑指 Offer 32 - II. 从上到下打印二叉树 II

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
    if root == nil { return [][]int{} }
    var res [][] int
    level := 0
    queue := list.New()
    queue.PushBack(root)
    for queue.Len() > 0{
        tmp := list.New()
        res = append(res, []int{})
        for queue.Len() > 0 {
            node := queue.Front().Value.(*TreeNode)
            queue.Remove(queue.Front())
            res[level] = append(res[level], node.Val)
            if node.Left != nil { tmp.PushBack(node.Left) }
            if node.Right != nil { tmp.PushBack(node.Right) }
        }
        queue = tmp
        level ++
    }
    return res
}

剑指 Offer 32 - III. 从上到下打印二叉树 III

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
    if root == nil { return [][]int{} }
    var res [][] int
    level := 0
    queue := list.New()
    queue.PushBack(root)
    for queue.Len() > 0{
        tmp := list.New()
        res = append(res, []int{})
        var tres []int 
        for queue.Len() > 0 {
            node := queue.Front().Value.(*TreeNode)
            queue.Remove(queue.Front())
            tres = append(tres, node.Val)
            if node.Left != nil { tmp.PushBack(node.Left) }
            if node.Right != nil { tmp.PushBack(node.Right) }
        }
        if level % 2 == 0 {
            res[level] = tres
        } else {
            for i := len(tres) - 1; i >= 0; i -- {
                res[level] = append(res[level], tres[i])
            }
        }
        queue = tmp
        level ++
    }
    return res
}

剑指 Offer 33. 二叉搜索树的后序遍历序列

func verifyPostorder(postorder []int) bool {
    return dfs(0, len(postorder) - 1, postorder)
}

func dfs(i, j int, postorder []int) bool {
    if i >= j { return true }
    p := i
    for postorder[p] < postorder[j] { p ++ }
    mid := p
    for postorder[p] > postorder[j] { p ++ }
    return p == j && dfs(i, mid - 1, postorder) && dfs(mid, j - 1, postorder)
}

剑指 Offer 34. 二叉树中和为某一值的路径

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func pathSum(root *TreeNode, sum int) [][]int {
    var res [][]int
    if root == nil { return res }
    dfs(root, sum, []int{}, &res)
    return res
}

func dfs(root *TreeNode, sum int, tmp []int, res* [][]int) {
    if root == nil { return }
    tmp = append(tmp, root.Val)
    if sum == root.Val && root.Left == nil && root.Right == nil {
        arr := make([]int,len(tmp))
        copy(arr, tmp)
        *res = append(*res, arr)
        return 
    }
    dfs(root.Left, sum - root.Val, tmp, res)
    dfs(root.Right, sum - root.Val, tmp, res)
}

剑指 Offer 35. 复杂链表的复制

/**
 * Definition for a Node.
 * type Node struct {
 *     Val int
 *     Next *Node
 *     Random *Node
 * }
 */

func copyRandomList(head *Node) *Node {
    if head == nil { return nil }
    p := head
    for p != nil {
        node := &Node{p.Val, nil, nil}
        node.Next = p.Next
        p.Next = node
        p = node.Next
    }
    p = head
    for p != nil {
        if p.Random != nil { p.Next.Random = p.Random.Next }
        p = p.Next.Next
    }
    p = head
    res := p.Next
    for p.Next != nil {
        tmp := p.Next
        p.Next = tmp.Next
        p = tmp
    }
    return res
}

剑指 Offer 38. 字符串的排列

func permutation(s string) []string {
    var res []string
    dict := map[string]bool{}
    str := []byte(s)
    var dfs func(idx int)
    dfs = func(idx int) {
        if idx == len(str) {
            dict[string(str)] = true
            return 
        }
        for i := idx; i < len(str); i ++ {
            t := str[idx]
            str[idx] = str[i]
            str[i] = t
            dfs(idx + 1)
            str[i] = str[idx]
            str[idx] = t
        }
    }
    dfs(0)
    for key, _ := range(dict) {
        res = append(res, key)
    }
    return res
}

剑指 Offer 39. 数组中出现次数超过一半的数字

func majorityElement(nums []int) int {
    cnt, res := 0, -0x3f3f3f3f
    for _, val := range(nums) {
        if val != res {
            cnt --
            if(cnt <= 0) {
                cnt = 1
                res = val
            }
        } else {
            cnt ++
        }
    }
    return res
}

剑指 Offer 40. 最小的k个数

func getLeastNumbers(arr []int, k int) []int {
    return arr[:qsort(arr, 0, len(arr) - 1, k)]
}

func qsort(arr []int, l int, r int, k int) int {
    if l == r { return k }
    p, v := l, arr[l]
    for i := l + 1; i <= r; i ++ {
        if arr[i] < v {
            p ++
            arr[i], arr[p] = arr[p], arr[i]
        }
    }
    arr[l], arr[p] = arr[p], arr[l]
    if p == k { 
        return p
    } else if k < p {
        return qsort(arr, l, p - 1, k) 
    } else {
        return qsort(arr, p + 1, r, k)
    }
}

剑指 Offer 42. 连续子数组的最大和

func max(x, y int) int {
    if x > y { return x }
    return y
}

func maxSubArray(nums []int) int {
    res, tmp := nums[0], nums[0]
    for i := 1; i < len(nums); i ++ {
        if tmp >= 0 {
            tmp += nums[i]
        } else {
            tmp = nums[i];
        }
        res = max(res, tmp)
    }
    return res
}

剑指 Offer 44. 数字序列中某一位的数字

func findNthDigit(n int) int {
    digits, bits := 1, 9
    for n - bits * digits > 0 {
        n = n - bits * digits
        bits = bits * 10
        digits ++
    }
    num := 1
    for k := 1; k < digits; k ++ {
        num = num * 10
    }
    num = num + (n - 1) / digits
    idx := (n - 1) % digits
    strnum := strconv.Itoa(num)
    res, _ := strconv.Atoi(string(strnum[idx]))
    return res
}

剑指 Offer 45. 把数组排成最小的数

func minNumber(nums []int) string {
    sort.Slice(nums, func(i, j int)bool {
        return cmp(nums[i], nums[j])
    })

    var ret string
    for _, num := range nums {
		ret += strconv.Itoa(num)
	}
	return ret
}

func cmp(i, j int) bool {
    a := (strconv.Itoa(i) + strconv.Itoa(j))
    b := (strconv.Itoa(j) + strconv.Itoa(i))
    return a < b
}

剑指 Offer 46. 把数字翻译成字符串

func translateNum(num int) int {
    if(num < 10) { return 1 }
    res := 0
    if num % 100 < 26 && num % 100 > 9 {
        res = res + translateNum(num / 100)
        res = res + translateNum(num / 10)
    } else {
        res = res + translateNum(num / 10)
    }
    return res
}

剑指 Offer 47. 礼物的最大价值

func maxValue(grid [][]int) int {
    dp := make([][]int, len(grid) + 1)
    for i := 0; i <= len(grid); i ++ {
        dp[i] = make([]int, len(grid[0]) + 1)
    }
    max := func(x, y int) int {
        if x > y { return x}
        return y
    }
    for i := 1; i <= len(grid); i ++ {
        for j := 1; j <= len(grid[0]); j ++ {
            dp[i][j] = grid[i - 1][j - 1] + max(dp[i][j - 1], dp[i - 1][j])
        }
    }
    return dp[len(grid)][len(grid[0])]
}

剑指 Offer 48. 最长不含重复字符的子字符串

func lengthOfLongestSubstring(s string) int {
    if len(s) == 0 { return 0 }
    var vis [256]bool
    res, l, r := 1, 0, 1
    vis[s[l]] = true
    max := func(x, y int) int {
        if x > y { return x }
        return y
    }
    for r < len(s) {
        for vis[s[r] - 0] {
            vis[s[l] - 0] = false
            l ++
        } 
        vis[s[r] - 0] = true
        r ++
        res = max(r - l, res)
    }
    return res
}

剑指 Offer 49. 丑数

type MinHeap []int

func (h MinHeap) Len() int {
	return len(h)
}

func (h MinHeap) Less(i, j int) bool {
	return h[i] < h[j]
}

func (h *MinHeap) Swap(i, j int) {
	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
}

func (h *MinHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *MinHeap) Pop() interface{}{
	res := (*h)[len(*h)-1]
	*h = (*h)[:len(*h)-1]
	return res
}

func nthUglyNumber(n int) int {
    h := make(MinHeap, 0)
    vis := make(map[int]bool)
    heap.Init(&h)
    heap.Push(&h, 1)
    for {
        t := heap.Pop(&h).(int)
        if vis[t] { continue }
        vis[t] = true
        n = n - 1
        if n == 0 { return t }
        heap.Push(&h, 2 * t)
        heap.Push(&h, 3 * t)
        heap.Push(&h, 5 * t)
    }
}

剑指 Offer 50. 第一个只出现一次的字符

func firstUniqChar(s string) byte {
    var vis [26]int
    for _, v := range(s) {
        vis[v - 'a'] ++
    }
    for _, v := range(s) {
        if vis[v - 'a'] == 1 {
            return byte(v)
        }
    }
    return ' '
}

剑指 Offer 51. 数组中的逆序对

func reversePairs(nums []int) int {
    if len(nums) == 0 { return 0 }    
    tmp := make([]int, len(nums))
    return mergesort(nums, tmp, 0, len(nums) - 1)
}

func mergesort(nums []int, tmp []int, l int, r int) int {
    if l == r { return 0 }
    mid := (l + r) / 2
    res := mergesort(nums, tmp, l, mid) + mergesort(nums, tmp, mid + 1, r)
    i, j, k := l, mid + 1, l;
    for i <= mid && j <= r {
        if nums[i] <= nums[j] {
            tmp[k] = nums[i]
            k ++
            i ++
        } else {
            tmp[k] = nums[j]
            k ++
            j ++
            res += mid - i + 1
        }
    }
    for i <= mid { 
        tmp[k] = nums[i] 
        k ++
        i ++
    }
    for j <= r { 
        tmp[k] = nums[j]
        k ++
        j ++
    }
    for i := l; i <= r; i ++ { nums[i] = tmp[i] }
    return res
}

剑指 Offer 52. 两个链表的第一个公共节点

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
    p1, p2 := headA, headB
    for p1 != p2 {
        if p1 == nil {
            p1 = headB
        } else {
            p1 = p1.Next
        }
        if p2 == nil {
            p2 = headA
        } else {
            p2 = p2.Next
        }
    }
    return p1
}

剑指 Offer 53 - I. 在排序数组中查找数字 I

func search(nums []int, target int) int {
    if len(nums) == 0 { return 0 }
    bs1 := func () int {
        l, r := 0, len(nums) - 1
        for l < r {
            mid := (l + r) / 2
            if target <= nums[mid] {
                r = mid
            } else {
                l = mid + 1
            }
        }
        return l
    }
    bs2 := func () int {
        l, r := 0, len(nums)
        for l < r {
            mid := (l + r) / 2
            if target < nums[mid] {
                r = mid
            } else {
                l = mid + 1
            }
        }
        return l
    }
    s1, s2 := bs1(), bs2()
    if(nums[s1] == target) { return s2 - s1 }
    return 0
}

剑指 Offer 53 - II. 0～n-1中缺失的数字

func missingNumber(nums []int) int {
    l, r := 0, len(nums)
    for l < r {
        mid := (l + r) / 2
        if mid < nums[mid] {
            r = mid
        } else {
            l = mid + 1
        }
    }
    return l
}

剑指 Offer 54. 二叉搜索树的第k大节点

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func kthLargest(root *TreeNode, k int) int {
    var res []int
    dfs(&res, root)
    return res[k - 1]
}

func dfs(nums *[]int, r *TreeNode) []int{
    if r.Right != nil{
        dfs(nums, r.Right)
    }
    if r != nil{
        *nums = append(*nums, r.Val)
    }
    if r.Left != nil{
        dfs(nums, r.Left)
    }
    return *nums
}

剑指 Offer 55 - I. 二叉树的深度

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func max(x, y int) int {
    if x > y { return x }
    return y
}

func maxDepth(root *TreeNode) int {
    if root == nil { return 0 }
    return max(maxDepth(root.Left), maxDepth(root.Right)) + 1
}

剑指 Offer 55 - II. 平衡二叉树

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isBalanced(root *TreeNode) bool {
    ans := true
    treeDepth(root, &ans)
    return ans
}

func max(x, y int) int {
    if x > y { return x }
    return y
}

func abs(x, y int) int {
    if x - y < 0 { return y - x }
    return x - y
}

func treeDepth(root *TreeNode, ans *bool) int {
    if root == nil { return 0 }
    l := treeDepth(root.Left, ans)
    r := treeDepth(root.Right, ans)
    if abs(l, r) > 1 {
        *ans = false
    }
    return max(l, r) + 1
}

剑指 Offer 56 - I. 数组中数字出现的次数

func singleNumbers(nums []int) []int {
    div, res, a, b := 1, 0, 0, 0
    for _, i := range(nums) {
        res ^= i
    }
    for (div & res) == 0 { div <<= 1 }
    for _, i := range(nums) {
        if i & div > 0 {
            a ^= i
        } else {
            b ^= i
        }
    }
    return []int{a, b}
}

剑指 Offer 56 - II. 数组中数字出现的次数 II

func singleNumber(nums []int) int {
    ans := 0
    for i := 0; i < 32; i ++ {
        cnt := 0
        for _, v := range(nums) {
            if ((1 << i) & v) > 0 {
                cnt ++
            }
        }
        if cnt % 3 != 0 {
            ans += (1 << i)
        }
    }
    return ans
}

剑指 Offer 57. 和为s的两个数字

func twoSum(nums []int, target int) []int {
    l, r := 0, len(nums) - 1
    for l < r {
        sum := nums[l] + nums[r]
        if sum == target {
            return []int{nums[l], nums[r]}
        } else if sum > target {
            r --
        } else {
            l ++
        }
    }
    return []int{}
}

剑指 Offer 57 - II. 和为s的连续正数序列

func findContinuousSequence(target int) [][]int {
    var res [][]int
    l, r := 1, 1
    for l <= r && r < target {
        sum := (l + r) * (r - l + 1) / 2
        if sum == target {
            tmp := []int{}
            for i := l; i <= r; i ++ {
                tmp = append(tmp, i)
            }
            res = append(res, tmp)
            l ++
        } else if sum < target {
            r ++
        } else {
            l ++
        }
    }
    return res
}

剑指 Offer 58 - I. 翻转单词顺序

func reverseWords(s string) string {
    //Split函数是用来分割字符串的，这里是按照空格分割 即使两个空格相邻，也是一个空的字符串
	strList := strings.Split(s," ")
	var res []string
	for i := len(strList) - 1; i >= 0; i -- {
        //TrimSpace用来去掉字符串中的空白字符串
		str := strings.TrimSpace(strList[i])
		if  len(str) > 0 {
			res = append(res,strList[i])
		}
	}
    //Join函数是用来将一系列字符串连接成一个整的字符串，这里是按照空格来连接
	return strings.Join(res," ")
}

剑指 Offer 58 - II. 左旋转字符串

func reverseLeftWords(s string, n int) string {
    return s[n:] + s[:n]
}

剑指 Offer 59 - I. 滑动窗口的最大值

func maxSlidingWindow(nums []int, k int) []int {
    deque := list.New()
    var res []int
    for i := 0; i < len(nums); i ++ {
        if deque.Len() > 0 && i - deque.Front().Value.(int) >= k { 
            deque.Remove(deque.Front())
        }
        for deque.Len() > 0 && nums[deque.Back().Value.(int)] <= nums[i] {
            deque.Remove(deque.Back())
        }
        deque.PushBack(i)
        if i >= k - 1 {
            res = append(res, nums[deque.Front().Value.(int)])
        }
    }
    return res
}

剑指 Offer 62. 圆圈中最后剩下的数字

func dfs(n, m int) int {
    if n == 1 { return 0 }
    x := dfs(n - 1, m)
    return (m + x) % n
}

func lastRemaining(n int, m int) int {
    return dfs(n, m)
}

剑指 Offer 63. 股票的最大利润

func min(x, y int) int {
    if x < y { return x }
    return y
}

func max(x, y int) int {
    if x > y { return x }
    return y
}

func maxProfit(prices []int) int {
    pre, ans := 0x3f3f3f3f, 0
    for i := 0; i < len(prices); i ++ {
        pre = min(pre, prices[i])
        ans = max(ans, prices[i] - pre)
    }
    return ans
}