张副官

秋游皖南川藏线

2023-12-15T16:41:27.000Z

自古逢秋悲寂寥

今年因为工作的原因，我和影姐俩一直没出过上海，可是出游的计划每周都会提起，求而不得的东西尤其显得珍贵。这周四又再次提起出去玩玩，想来在新公司已经996一个月了，调休用不完，所以就下周一请假，加上这周末俩天，三天的时间也能去周边溜达一下。开始想去的是黄山，赶上淡季不会太堵，攻略和酒店都看好之后，我突发奇想去瞅了一下天气，发现黄山周六60%会下中雨，所以临时改了方案，可是直到睡觉前都没看好，不过咱们俩决定了这周一定要出去，明天八点起床再说。第二天起床之后，我去之前加的周边游的群里问了一下，群主推荐了他之前在皖南川藏线的游记，整条线路都是自然风光，很契合我们俩的口味，二话没说立刻开整，洗漱了一下并且点了早餐外卖，9点30从浦东出发，第一站目的地：皖南川藏线东入口。

我们是从浦东金杨出发、上沪渝高速从广德收费站下车，到达广德收费站已经是下午1点多，于是下高速后一路在沿线觅食，在一个镇子上面的小面馆吃了一碗三鲜面和番茄鸡蛋面，味道真的很不错，感觉汤底是自己熬出来的，而且价格实惠。吃完之后看到旁边有旁边小卖部想着买点零食去路上吃，于是发现了我非常喜欢吃的炒年糕片（不知道当地是不是这样叫的），开始以为是猫耳朵，后来下午吃的时候才发现脆脆的、米香十足、微微甜，和猫耳朵的味道截然不同，后面一路上一直没找到有，回来在网上买回来的也差强人意。吃完午餐之后一路西行，其实此时已经感受这边独特的景色，满山遍野都是竹子，真的是竹林竹海，加上今年秋冬来的迟滞，气温还维持在26度上下，一些树叶也是深绿，所以给的感觉还停留在夏天。中途还会穿越宁国市，可以加一些补给，看到了影姐喜欢点的奶茶店，问她喝不喝，她眯着眼睛让我别吵她睡觉，后来提起此事，说我故意的不提醒她，不让她喝奶茶。大约下午两点半我们就到达“皖南川藏线”的东入口。

打卡流程走完之后就真正开始了这次主线，我们的第一个目的地是水墨汀溪，第一天的酒店就预定在那。大约行驶40分钟就到酒店了，我们这次预定的是一家农家乐，感觉一般，整个房间虽然有个阳台，但是通风不行。办理好酒店入住之后我们俩就打算去周边逛逛。这边主要的一个景点是早上7点去水墨汀溪那边坐竹排，悠悠行驶在水雾弥漫之中。

晚上在酒店的臭鳜鱼，我们俩口味重，提前说了要了中辣，还能接受。第二天吃完早餐便离开了酒店，前往青龙湾左东风桥码头坐船，酒店到码头不到20分钟行驶旅程，我们到的时候已经零散有几个人上船，9点开始出发。青龙湾比较大，水很清澈，加之今年是暖秋，树叶都没有变黄，让人感觉身处盛夏。

邮轮会达到青龙寺脚下，有1个小时的时间前往青龙寺游玩，其实就是一个200来步的石阶，寺庙不大，现在也是淡季，所以人流不多。我们俩很快就游玩了，便开始了下一个目的地：落羽红杉林。其实这个时间在往年看来恰是红杉林树叶正红之时，不过今年入冬较晚，气温居高不下，所以我们来的时候叶子大概只红了三分之一。

游玩打开半小时之后，就准备觅食了，在沿途还看到了一片金色的稻田。

吃了当地的咸菜炖猪脚，味道还行，价格也能接受。吃香喝足直奔今天最后一个景点：桃林六道湾。桃林六道湾主要游玩点在于沿途的风景和较为有挑战的路线。沿路此起彼伏、蜿蜒曲折的柏油路，路两侧由之前的竹林逐渐过渡到丛灌树木，路面干净整洁，两侧的民房也是错落有致。

其实走完桃林六道湾我们的旅途差不多就接近尾声，我问老婆要不要直接回上海，她说太累了没必要，虽然现在才4点半，毕竟也要开将近5个小时的车程。我们便去水墨汀溪附近找了一家民宿休息，前往民宿路程中秋风肃起，漫天的落叶在空中肆意的摇曳，天空已经愈发暗沉，街上行人和车辆也不见一二，此时顿感秋意正浓。第二天9点多在民宿吃了点面条，直奔上海。

《题西溪无相院》

宋代 / 张先

积水涵虚上下清，几家门静岸痕平。

浮萍破处见山影，小艇归时闻棹声。

入郭僧寻尘里去，过桥人似鉴中行。

已凭暂雨添秋色，莫放修芦碍月生。

斋见

2023-09-11T15:51:36.000Z

昔人已乘黄鹤去，此地空余黄鹤楼。
黄鹤一去不复返，白云千载空悠悠。

二叉树层次遍历

2023-06-29T17:00:25.000Z

leetcode-二叉树层序遍历

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
    // write code here
    if root == nil {
        return nil
    }

    res := make([][]int, 0)
    // 使用slice来保存队列
    list := make([]*TreeNode, 0)
    // 从root节点开始
    list = append(list, root)
    listLen := len(list)

    for len(list) > 0 {
        // 下一层的数量
        nextLevelLen := 0
        // 本轮的结果
        path := make([]int, 0)

        // 每一层遍历
        for listLen > 0 {
            // 弹出一个节点
            node := list[0]
            listLen--
            path = append(path, node.Val)

            // 如果list只有一个元素，则重新初始化一下
            if len(list) == 0 {
                list = make([]*TreeNode, 0)
            } else {
                list = list[1:]
            }

            if node.Left != nil {
                list = append(list, node.Left)
                nextLevelLen++
            }

            if node.Right != nil {
                list = append(list, node.Right)
                nextLevelLen++
            }
        }

        // 遍历完成
        res = append(res, path)
        listLen = nextLevelLen
    }

    return res
}

lru简易理解版本

2023-06-28T16:03:22.000Z

分析需求

Get

如果节点存在：

将节点从当前位置删除
将节点移动到第一个位置

如果节点不存在: 直接返回-1

Put

如果节点存在：

更新value
将节点从当前位置删除
将节点移动到第一个位置

如果节点不存在：size < cap

将节点直接移动到第一个位置
节点放入map
size+1

如果节点不存在：size >= cap (其实不存在>情况，这里方便理解)

将节点直接移动到第一个位置
将末尾节点删除
将末尾节点从map删除

总结

归纳下来主要有俩个操作：

将节点直接移动到第一个位置
将节点从当前位置删除
备注：为了便于操作，我们将tail和head设置为虚拟节点，这样就不需要考虑边界情况，操作起来非常nice

实现

// 节点
type Node struct {
    Key int
    Value int
    Next *Node
    Pre *Node
}

type LRUCache struct {
    Cap int
    Size int
    NodeMap map[int]*Node
    // 头部指针
    Head *Node
    // 末尾指针
    Tail *Node
}

func Constructor(capacity int) LRUCache {
    lru := LRUCache{
        Cap: capacity,
        Size: 0,
    }
    lru.NodeMap = make(map[int]*Node, 0)
    lru.Tail = &Node{}
    lru.Head = &Node{}

    return lru
}

// 将节点移动放置到头部节点
func (this *LRUCache) moveToHead(node *Node) {
    if this.Size == 0 {
        this.Head.Next = node
        node.Pre = this.Head
        this.Tail.Pre = node
        node.Next = this.Tail
        return
    }

    // 节点的Next是之前头部节点的next
    node.Next = this.Head.Next
    // 之前的第一个节点的pre节点是当前节点
    this.Head.Next.Pre = node
    // 节点的pre节点是头部指针
    node.Pre = this.Head
    // 头部指针next指向node
    this.Head.Next = node
}

// 删除节点
func (this *LRUCache) delNode(node *Node) {
    node.Pre.Next = node.Next
    node.Next.Pre = node.Pre
}


func (this *LRUCache) Get(key int) int {
    node, ok := this.NodeMap[key]
    if !ok {
        return -1
    }

    // 1. 将节点从当前位置删除
    this.delNode(node)

    // 2. 将该节点移动到头部位置
    this.moveToHead(node)

    return node.Value
}


func (this *LRUCache) Put(key int, value int)  {
    existNode, ok := this.NodeMap[key]
    if ok {
        // 如果已经存在
        existNode.Value = value

        // 从当前位置删除
        this.delNode(existNode)
        // 移动到头部位置
        this.moveToHead(existNode)

        return
    }


    node := &Node{
        Key: key,
        Value: value,
    }
    // 首先加载到map中
    this.NodeMap[key] = node

    // 1. 如果size < cap
    if this.Size < this.Cap {
        // 1.1 将节点放到头部位置
        this.moveToHead(node)
        // 1.2 size+1
        this.Size++
    } else {
        // 2. 如果size = cap
        // 2.1 讲节点放到头部位置
        this.moveToHead(node)

        // 2.2 删除末尾节点
        nowTailPre := this.Tail.Pre
        this.delNode(nowTailPre)
        // 从map里面删除
        delete(this.NodeMap, nowTailPre.Key)
    }
}

飞向：leetcode-lru

双指针-链表拆分与合并

2023-06-20T15:08:30.000Z

教程

双指针技巧秒杀七道链表题目

题目

合并两个有序链表

力扣-21-合并两个有序链表

只用两个指针指向两个链表，每次取值的时候移动，如果俩链表中至少有一个遍历完成则结束，把没遍历完成的链表直接放在新链表的后面

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {
    // 此处纯属优化
    if list1 == nil {
        return list2
    }
    if list2 == nil {
        return list1
    }

    head := &ListNode{}
    // 这里为啥要重新赋值一下，因为最终结果需要返回第一个节点
    node := head
    p1 := list1
    p2 := list2

    for p1 != nil && p2 != nil {
        if p1.Val < p2.Val {
            node.Next = p1
            p1 = p1.Next
        } else {
            node.Next = p2
            p2 = p2.Next
        }
        node = node.Next
    }
    // 为啥有下面这两行，是因为可能某一个遍历完成，而另外一个还没有，姐可以直接放在后面了
    if p1 != nil {
        node.Next = p1
    }
    if p2 != nil {
        node.Next = p2
    }

    // 这里为啥是next, 因为我们为了方便head是一个无效的节点
    return head.Next
}

分隔链表

力扣-86-分隔链表

使用两个链表分别保存小于和大于或等于的值，最后合并。需要注意俩个点：1. 目标链表每遍历一个节点就把指针往后移动，并断开前面的节点；2. 合并的时候只需要判断保存大值的连边是否为空，如果不为空直接放在小值连边后面，最后返回小值链表的头部（注意：我们为了操作方便，在定义链表的时候第一个节点是无效节点，所以表头节点是第二个节点）。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func partition(head *ListNode, x int) *ListNode {
    p1 := &ListNode{}
    p1Head := p1
    p2 := &ListNode{}
    p2Head := p2

    for head != nil {
        if head.Val < x {
            p1.Next = head
            p1 = p1.Next
        } else {
            p2.Next = head
            p2 = p2.Next
        }

        // 断开已经处理完成的节点
        temp := head.Next
        head.Next = nil
        head = temp
    }

    // 大值链表不为空就直接放在后面
    if p2Head.Next != nil {
        p1.Next = p2Head.Next
    }

    return p1Head.Next
}

反馈倒数第K个节点

力扣-2-返回倒数第K个节点

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func kthToLast(head *ListNode, k int) int {
    p := head

    for i := 1; i <= k; i++ {
        head = head.Next
    }

    for head != nil {
        head = head.Next
        p = p.Next
    }

    return p.Val
}

返回中间接点

其实就是利用快慢指针

力扣-876-链表中加结点

func middleNode(head *ListNode) *ListNode {
    fast, slow := head, head

    for fast != nil && fast.Next != nil {
        fast = fast.Next.Next
        slow = slow.Next
    }

    return slow
}

环形链表

力扣-141-环形链表

func hasCycle(head *ListNode) bool {
    fast, slow := head, head

    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
        if slow == fast {
            return true
        }
    }

    return false
}

环形链表II

环形链表II【基础算法精讲 07】_哔哩哔哩_bilibili
力扣-142-环形链表II

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func detectCycle(head *ListNode) *ListNode {
    slow, fast := head, head

    for fast != nil && fast.Next != nil {
        fast = fast.Next.Next
        slow = slow.Next

        if fast == slow {
            for head != slow {
                head = head.Next
                slow = slow.Next
            }

            return slow
        }
    }

    return nil
}

相交链表

力扣-160-相交链表

双指针-暴力破解

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

        headA = headA.Next
    }

    return nil
}

双指针-拼接

把两个链表拼接到一起

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
    a, b := headA, headB

    for a != b {
        if a == nil {
            a = headB
        } else {
            a = a.Next
        }

        if b == nil {
            b = headA
        } else {
            b = b.Next
        }
    }

    return a
}

双指针-N数之和

2023-06-15T15:08:13.000Z

教程

两数之和三数之和【基础算法精讲 02】_哔哩哔哩_bilibili
一个方法团灭 nSum 问题 :: labuladong的算法小抄

题目

两数之和

力扣-1-两数之和

hash表

func twoSum(nums []int, target int) []int {
    numsMap := make(map[int]int, 0)

    for i, v := range nums {
        if index, ok := numsMap[target-v]; ok {
            return []int{index, i}
        }

        numsMap[v] = i
    }

    return nil
}

暴力破解双遍历

func twoSum(nums []int, target int) []int {
    for i := 0; i< len(nums); i++ {
        for j := i+1; j<len(nums); j++ {
            if nums[i] + nums[j] == target {
                return []int{i, j}
            }
        }
    }

    return nil
}

三数之和

力扣-15-三数之和

func threeSum(nums []int) [][]int {
    // 排序
    sort.Ints(nums)
    // 保存结果
    res := make([][]int, 0)
    // 数组长度
    n := len(nums)

    // 这里为什么-2？
    // 因为这是有序数组，如果有复合条件的结果[下表i,j,k]必然是i
    for i := 0; i < n-2; i++ {
        // 首先nums是有序数组
        // 如果某一列中最小的两个数之和加起来都大于0，则说明和其余的数加起来必然大于0
        if i > 0 && nums[i]+nums[i-1] > 0 {
            break
        }

        // 元素相同，避免重复，则跳过
        if i>0 && nums[i] == nums[i-1] {
            continue
        }

        j := i+1 // 中间位置
        k := n-1 // 最大值的位置，即最右边的位置
        for j < k {
            sum := nums[i]+nums[j]+nums[k]

            if sum == 0 {
                res = append(res, []int{nums[i], nums[j], nums[k]})

                // 还需要排除重复的
                j++
                for j < k && nums[j]==nums[j-1] {
                    j++
                }

                k--
                for j < k && nums[k] == nums[k+1] {
                    k--
                }
            }
            
            if sum < 0 {
                // 小于0， 则说明中间值太小了，j需要往右边移动
                j++
            }

            if sum > 0 {
                // 大于0，则说明中间值太大了，需要将最右边的k往左边移动
                k--
            }
        }
    }

    return res
}

四数之和

力扣-18-四数之和

// 其实和三数之和是一个意思，就是先固定第一个数，然后三个数按照三数之和来处理
func fourSum(nums []int, target int) [][]int {
    if len(nums) < 4 {
        return nil
    }
    sort.Ints(nums)

    res := make([][]int, 0)
    for i :=0; i<len(nums)-3; i++ {
        if i > 0 && nums[i-1] == nums[i] {
            continue
        }
 
        for j := i+1; j<len(nums)-2; j++ {
            if j>i+1 && nums[j] == nums[j-1] {
                continue
            }

            k := j+1
            r := len(nums)-1

            for k < r {
                sum := nums[i]+nums[j]+nums[k]+nums[r]
                if sum < target {
                    k++
                }

                if sum  > target {
                    r--
                }

                if sum == target {
                    res = append(res, []int{nums[i],nums[j],nums[k],nums[r]})
                    k++
                    for k < r && nums[k]==nums[k-1] {
                        k++    
                    }
                    r--
                     for k < r && nums[r]==nums[r+1] {
                        r--    
                    }
                }
            }

        }
    }

    return res
}

二叉树深度问题

2023-06-13T00:11:10.000Z

最小深度

func minDepth(root *TreeNode) int {
if root == nil {
return 0
}
minDepth := math.MaxInt64
var dfs func(node *TreeNode, depth int)
dfs = func(node *TreeNode, depth int) {
if node == nil {
return
}
depth ++
if node.Left == nil && node.Right == nil {
if depth < minDepth {
minDepth = depth 
}
}
dfs(node.Left, depth)
dfs(node.Right, depth)
}
dfs(root, 0)
return minDepth
}

最大深度

func maxDepth(root *TreeNode) int {
if root == nil {
return 0
}
minDepth := 0
var dfs func(node *TreeNode, depth int)
dfs = func(node *TreeNode, depth int) {
if node == nil {
return
}
depth ++
if node.Left == nil && node.Right == nil {
if depth > minDepth {
minDepth = depth 
}
}
dfs(node.Left, depth)
dfs(node.Right, depth)
}
dfs(root, 0)
return minDepth
}

dfs-岛屿问题

2023-06-11T05:03:27.000Z

题目

力扣-200-岛屿数量
 力扣-695-岛屿最大面积
 力扣-1254-封闭岛屿数量

思路讲解

labuladong-一文搞定岛屿问题

岛屿数量

func numIslands(grid [][]byte) int {
    if len(grid) == 0 {
        return 0
    }
    if len(grid[0]) == 0 {
        return 0
    }

    // 记录总的结果
    res := 0
    m := len(grid)
    n := len(grid[0])
    for i := 0; i
        for j := 0; j
            if grid[i][j] == '1' {
                res++
                toWater(grid, i, j)
            }
        }
    }

    return res
}

func toWater(grid [][]byte, i, j int) {
    m := len(grid)
    n := len(grid[0])
    
    var dfs func(grid [][]byte, r, c int)
    dfs = func(grid [][]byte, r, c int) {
        if r < 0 || c < 0 || r >= m || c >= n {
            return
        }

        // 已经是海水
        if grid[r][c] == '0' {
            return
        }
        // 遍历过的陆地转为海水
        grid[r][c] = '0'

        dfs(grid, r-1, c)
        dfs(grid, r+1, c)
        dfs(grid, r, c-1)
        dfs(grid, r, c+1)
    }
    dfs(grid, i, j)
}

岛屿最大面积

func maxAreaOfIsland(grid [][]int) int {
    m := len(grid)
    n := len(grid[0])
    maxIsland := 0

    for i:=0; i
        for j:=0; j
            if grid[i][j] == 1 {
                nowIsland := toWater(grid, i, j)
                if nowIsland > maxIsland {
                    maxIsland = nowIsland
                }
            }
        }
    }

    return maxIsland
}

func toWater(grid [][]int, i, j int) int {
    m := len(grid)
    n := len(grid[0])
    sum := 0
    
    var dfs func(grid [][]int, r, c int)
    dfs = func(grid [][]int, r, c int) {
        if r < 0 || c < 0 || r>=m || c >= n {
            return
        }

        if grid[r][c] == 0 {
            return
        }
        sum++
        grid[r][c] = 0

        dfs(grid, r-1, c)
        dfs(grid, r+1, c)
        dfs(grid, r, c-1)
        dfs(grid, r, c+1)
    }
    dfs(grid, i, j)

    return sum
}

封闭岛屿数量

func closedIsland(grid [][]int) int {
    m := len(grid)
    n := len(grid[0])

    // 把第一行和最后一行的岛屿转为海水
    for j := 0; j
        toWater(grid, 0, j)
        toWater(grid, m-1, j)
    }

    // 把第一列和最后一列转为海水
    for i := 0; i
        toWater(grid, i, 0)
        toWater(grid, i, n-1)
    }

    res := 0
    for i :=0; i
        for j := 0; j
            if grid[i][j] == 0 {
                res++
                toWater(grid,i,j)
            }
        }
    }

    return res
}

func toWater(grid [][]int, i, j int) {
    m := len(grid)
    n := len(grid[0])

    var dfs func(grid [][]int, r, c int)
    dfs = func(grid [][]int, r, c int) {
        if r < 0 || c < 0 || r >=m || c >=n {
            return
        }
        if grid[r][c] == 1 {
            return
        }

        grid[r][c] = 1

        dfs(grid, r, c-1)
        dfs(grid, r, c+1)
        dfs(grid, r-1, c)
        dfs(grid, r+1, c)
    }
    dfs(grid, i, j)
    return
}

双指针-子数字问题

2023-06-11T04:54:30.000Z

题目大纲

力扣-209-长度最小的子数组
 力扣-713-乘积小于K的子数组
 力扣-1004-最大连续1的个数III
力扣-1234-替换子串得到平衡串
 力扣-1658-将x减到0的最小操作数

思路讲解

同向双指针滑动窗口【基础算法精讲 01】_哔哩哔哩_bilibili

长度最小的子数组

func minSubArrayLen(target int, nums []int) int {
    minLen := len(nums)+1 // 这里保证初始量比最大值还大就行，还有一种方式是直接用math.MaxInt
    left := 0
    sum := 0

    for right:= 0; right < len(nums); right++ {
        sum = sum + nums[right]

        for sum >= target {
            nowLen := right-left+1
            if nowLen < minLen {
                minLen = nowLen
            }

            // 移动左指针
            sum = sum - nums[left]
            left++
        }
    }

    if minLen == len(nums)+1 {
        return 0
    }
    return minLen
}

乘积小于k的子数组

核心点在于：假设左指针为left，右指针为right，则固定right点，所有满足条件的子数组数量为：right-left+1

func numSubarrayProductLessThanK(nums []int, k int) int {
    if k <= 1 {
        return 0
    }

    res := 0
    left := 0
    product := 1

    for right := 0; right < len(nums); right++ {
        product = product * nums[right]

        for product >= k {
            product = product/nums[left]
            left++
        }

        res = res + (right-left+1)
    }

    return res
}

无重复字符的最小子串

使用简单map

首先使用map保存right遍历过的节点，key为字符对应的字节，value为字节在字符串数组中的位置
如果没有重复，则当前无重复结果now+1，并且把当前字符加入到map中

如果有重复，则把left指针移动到重复节点的后面一个，并且需要删除原来left-》重复节点，最后把当前节点计入map

func lengthOfLongestSubstring(s string) int {
    if len(s) == 0 {
        return 0
    }

    strMap := make(map[byte]int, 0)
    left := 0
    now := 0
    max := 0

    for right:=0; right < len(s); right++ {
        if existIndex, ok := strMap[s[right]]; ok {
            for left < existIndex+1 {
                delete(strMap, s[left])
                left++
            }
            left = existIndex+1
            strMap[s[right]] = right
        } else {
            strMap[s[right]] = right
            now = right-left+1
            if now > max {
                max = now
            }
        }
    }

    return max
}

有更好的做法》》》》》 hhhh, 是我看大佬教程学到的，上面是自己琢磨的。

使用map计数器

func lengthOfLongestSubstring(s string) int {
    if len(s) == 0 {
        return 0
    }

    strCounter := make(map[byte]int, 0)
    left := 0
    max := 0

    for right := 0; right < len(s); right++ {
        strCounter[s[right]]++

        for strCounter[s[right]] > 1 {
            strCounter[s[left]]--
            left++
        }

        if right-left+1 > max {
            max = right-left+1
        }
    }

    return max
}

最大连续1的个数III

关键在于Counter的设计

func longestOnes(nums []int, k int) int {
    if len(nums) <= k {
        return len(nums)
    }

    left := 0
    maxLen := 0
    zeroCounter := make(map[int]int, 0)

    for right := 0; right < len(nums); right++ {
        zeroCounter[nums[right]]++

        if nums[right] == 0 {
            for zeroCounter[nums[right]] > k {
                zeroCounter[nums[left]]--
                left++
            }
        }

        if right-left+1 > maxLen {
            maxLen = right-left+1
        }
    }

    return maxLen
}

替换子串得到平衡串

假设字符串长度为n
如果Q/W/E/R的出现次数都等于n/4，则说明已经平衡了

如果除了子串之外的字符Q/W/E/R的出现次数都小于或等于n/4，说明可以通过子串的填补来实现平衡；如果大于n/4则说明无法通过当前子串来实现平衡（因为你无法改变子串之外的字符，比如QQQ[QWERR]，子串QWERR之外的字符中Q出现了三次大于2，则你无论如何改变子串都无法实现平衡；反之，如果是这样的QQR[QWERR]，则可以将子串改变为[WWERE]=>QQRWWERE,便实现了平衡）。

func balancedString(s string) int {
    counter := make(map[byte]int, 0)
    for i := 0; i<len(s); i++ {
        counter[s[i]]++
    }
    left := 0
    m := len(s)/4
    min := math.MaxInt // 其实这个只是定义一个最大值

    // 如果WQER四个字符的个数恰好是m，则说明已经是平衡字符串了
    if counter['Q'] == m &&
        counter['W'] == m &&
          counter['E'] == m &&
            counter['R'] == m {
        return 0
    }

    for right:=0; right<len(s); right++ {
        // 属于子串范围的就应该减去
        counter[s[right]]--

        for counter['Q'] <= m &&
                counter['W'] <= m &&
                    counter['E'] <= m &&
                        counter['R'] <= m {
            if right-left+1 < min {
                min = right-left+1
            }
            counter[s[left]]++ // 移除了子串的范围就应该放到其他的里面， counter始终是维护子串之外的数据
            left++
        }
    }
    return min
}

将X减到0的最小操作数

其实这一题和上面：力扣-209-长度最小的子数组是一模一样的，可以理解为和为allSum-x的最小子串，稍微变了一下而已

func minOperations(nums []int, x int) int {
    left := 0
    min := math.MaxInt
    sum := 0

    allSum := 0
    for _, v := range nums {
        allSum = allSum + v
    }
    // 总和小于指定的值，肯定不符合
    if allSum < x {
        return -1
    }
    // 其实这一题可以转变一个思路，就是求满足子串总和=allSum-x的最小子串
    otherSum := allSum - x

    for right:=0; right<len(nums); right++ {
        sum = sum + nums[right]

        for sum > otherSum {
            sum = sum - nums[left]
            left++
        }

        if sum == otherSum {
            subNumsLen := right-left+1
            otherNumerLen := len(nums) - subNumsLen
            if otherNumerLen < min {
                min = otherNumerLen
            }
        }
    }

    if min == math.MaxInt {
        min = -1
    }
    
    return min
}

go适配器模式

2023-06-02T15:53:20.000Z

适配器模式是一种结构型设计模式，它允许具有不兼容接口的对象进行协作。这种模式通常用于以下情况：

当你想使用某个现有类，但其接口与你的代码不兼容时。
当你想重用多个现有子类，但它们缺少一些无法添加到超类中的通用功能时。
适配器模式的解决方案是创建一个适配器类，它充当你的代码和遗留类、第三方类或任何其他具有奇怪接口的类之间的翻译器。适配器包装了一个对象，隐藏了其背后的转换复杂性。被包装的对象甚至不知道适配器的存在。

package main

import "fmt"

func main() {
a := NewAdapter()
a.Pay("张三", 12, "aliyun")
a.Pay("李四", 200, "wx")
}

type AliyunPayInterface interface {
Pay(name string, payment float64)
}

type AliyunPay struct{}

func (a AliyunPay) Pay(name string, payment float64) {
fmt.Printf("用户【%s】支付宝支付金额【%f】元 \n", name, payment)
}

type WxPayInterface interface {
Pay(name string, payment float64)
}
type WxPay struct {
}

func (w WxPay) Pay(name string, payment float64) {
fmt.Printf("用户【%s】微信支付金额【%f】元 \n", name, payment)
}

type Apadter struct {
AliyunPayInterface
WxPayInterface
}

func (a Apadter) Pay(name string, payment float64, channel string) {
if channel == "aliyun" {
a.AliyunPayInterface.Pay(name, payment)
} else if channel == "wx" {
a.WxPayInterface.Pay(name, payment)
} else {
fmt.Printf("不支持的支付渠道")
}
}

func NewAdapter() Apadter {
return Apadter{
AliyunPay{},
WxPay{},
}
}

go观察者模式

2023-06-02T15:50:53.000Z

package main

import "fmt"

func main() {
sub := NewSubject("东北")
sub.Register(Observer{
Uid:  123,
Name: "张三",
})
sub.Register(Observer{
Uid:  124,
Name: "李四",
})

sub.NotifyAll()
}

// ObserverInterface 观察者
type ObserverInterface interface {
Notify()
}

// Observer 具体观察者
type Observer struct {
Uid  int32
Name string
}

func (o Observer) Notify() {
fmt.Printf("观察者【%d】：%s \n", o.Uid, o.Name)
}

// SubjectInterface 主体，也就是观察者模式的主体
type SubjectInterface interface {
Register(o ObserverInterface)
Deregister(o ObserverInterface)
NotifyAll()
}

type Subject struct {
observerMap map[int32]Observer
name        string
}

func NewSubject(name string) *Subject {
return &Subject{
name:        name,
observerMap: map[int32]Observer{},
}
}

func (s *Subject) Register(o Observer) {
if _, ok := s.observerMap[o.Uid]; ok {
return
}

s.observerMap[o.Uid] = o
}

func (s *Subject) Deregister(o Observer) {
if _, ok := s.observerMap[o.Uid]; !ok {
return
}
delete(s.observerMap, o.Uid)
}

func (s *Subject) NotifyAll() {
for _, o := range s.observerMap {
o.Notify()
}
}

dfs之查找二叉树最大深度

2023-06-01T15:47:21.000Z

传送到leetcode: leetcode-104

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
// dfs实现
func maxDepth(root *TreeNode) int {
    max := 0
    startDeep := 0

    var dfs func(node *TreeNode, startDeep int)
    dfs = func(node *TreeNode, startDeep int) {
        if node == nil {
            return
        }
        startDeep = startDeep + 1

        if node.Left == nil && node.Right == nil {
            if startDeep > max {
                max = startDeep
            }
        }

        dfs(node.Left, startDeep)
        dfs(node.Right, startDeep)
    }

    dfs(root, startDeep)
    return max
}

go实现lru

2023-05-31T14:25:23.000Z

原理：定义lru结构的时候主要包含一个哈希表和双向链表，哈希表便于获取指定key的数据（复杂度O(1)），把每次热点数据都更新到表头，则从表头到表尾访问热度依次递减，溢出的时候直接删除表尾数据即可。

go代码实现：

package main

import (
"fmt"
"log"
)

func main() {
log.Print("zlru...")

l := NewLruCache(5)
l.Put(1, 11)
l.Put(2, 22)
l.Put(3, 33)
l.Put(4, 44)
l.Put(5, 55)

log.Println("case1------------------------------->")
log.Printf("head: %+v", l.list.head)
log.Printf("tail: %+v", l.list.tail)
log.Printf("len: %d", l.size)
l.list.Range()

log.Println("case2------------------------------->")
l.Put(6, 66)
log.Printf("head: %+v", l.list.head)
log.Printf("tail: %+v", l.list.tail)
log.Printf("len: %d", l.size)
l.list.Range()

log.Println("case3------------------------------->")
l.Get(3)
log.Printf("head: %+v", l.list.head)
log.Printf("tail: %+v", l.list.tail)
log.Printf("len: %d", l.size)
l.list.Range()
}

func (l *linkList) Range() {
for node := l.head; node != nil; node = node.next {
fmt.Printf("key: %d, value: %d \n", node.key, node.value)
}
}

// 双向链表节点
type linkNode struct {
key   int
value int
prev  *linkNode
next  *linkNode
}

// 双向链表
type linkList struct {
head *linkNode
tail *linkNode
}

// lru缓存结构
type lruCache struct {
cap      int
size     int
cacheMap map[int]*linkNode
list     *linkList
}

func newNode(k, v int) *linkNode {
return &linkNode{
key:   k,
value: k,
}
}

// NewLruCache 初始化一个新的lru
func NewLruCache(cap int) *lruCache {
l := &lruCache{
cap:  cap,
size: 0,
}
l.cacheMap = make(map[int]*linkNode, 0)
l.list = &linkList{
head: nil,
tail: nil,
}

return l
}

// 主要是需要实现两个操作：Get/Put
// Get 获取指定key的值：
//     1. 如果key存在，则需要将该key所在的节点：（1）从当前位置删除，（2）移动到链表头部
//     2. 如果不存在直接返回-1
// Put 新增元素：
//     1. 如果key存在，则需要将该key所在的节点：（1）更新当前节点的值，（2）从当前位置删除，（2）移动到链表头部
//     2. 如果key不存在，则需要：（1）新生成一个节点NewNode, （2）将NewNode放在链表头部，（3）链表长度加1，如果此时链表长度未超过容量cap则直接返回，（4）如果加1后的链表长度超过容量则删除链表末尾节点，删除map中的元素
// 其实归结下来有以下几个基础操作：
//  （1）删除一个已经存在的元素 （2）删除链表中末尾元素（3）将元素放在链表头部

func (l *lruCache) removeNode(node *linkNode) {
// 如果node是最后一个元素, 并且prev元素不为空
if node.next == nil && node.prev != nil {
node.prev.next = nil
l.list.tail = node.prev
return
}

// 如果node是第一个元素, 并且next元素不为空
if node.prev == nil && node.next != nil {
node.next.prev = nil
l.list.head = node.next
return
}

// 如果只有一个元素
if node.prev == nil && node.next == nil {
l.list.tail = nil
l.list.head = nil
return
}

// 删除中间元素
node.prev.next = node.next
node.next.prev = node.prev
}

func (l *lruCache) removeTail() {
if l.list.tail == nil {
return
}
l.removeNode(l.list.tail)
delete(l.cacheMap, l.list.tail.key)
}

func (l *lruCache) moveHead(node *linkNode) {
// 一个元素都没有
if l.list.head == nil {
l.list.head = node
l.list.tail = node
return
}

headNode := l.list.head
// 新节点的next指向头部节点
node.next = headNode
// 头部节点的prev指向新节点
headNode.prev = node
// 新节点的prev设置为nil
node.prev = nil
// 双向链表的头部指向新的节点
l.list.head = node
}

func (l *lruCache) Get(key int) int {
// 判断key是否存在
node, ok := l.cacheMap[key]
if !ok {
return -1
}

// 删除节点在之前的位置
l.removeNode(node)
// 将节点移动到头部
l.moveHead(node)
return node.value
}

func (l *lruCache) Put(key, value int) {
// 判断节点是否存在
node, ok := l.cacheMap[key]
if !ok {
// 如果不存在则需要新生产一个node， 并指向链表头部
newNode := newNode(key, value)
// 向cap里面新增一对k/v
l.cacheMap[key] = newNode
// 将新增的node放在链表头部
l.moveHead(newNode)
// 链表长度加1
l.size++
// 如果长度超过容量则需要删除链表末尾元素
if l.size > l.cap {
l.removeTail()
l.size--
}
return
}

// 如果新增元素已经存在
// 更新元素的值
node.value = value
// 将元素从当前位置删除
l.removeNode(node)
// 将元素移动到链表头部
l.moveHead(node)
}

go容易忽视的黑坑系列2

2023-05-28T13:15:26.000Z

推断下面代码输出结果：


var f = func(i int) {
fmt.Println("x")
}

func main(){
f := func(i int) {
println(i)

if i > 0 {
f(i-1)
}
}

f(10)
}

可能有同学会测试为：

但实际是：

1
2

3
x

这是因为main函数在构造的时候全局f函数已经构造完成，所以使用的是全局f函数。而且如果改成为我们想像的逻辑，反而会报错：

func main(){
fi := func(i int) {
println(i)

if i > 0 {
fi(i-1)
}
}

f(3)
}

// 错误：
# command-line-arguments
./main.go:314:4: undefined: fi

N皇后问题

2023-05-28T12:20:23.000Z

// 是否冲突
//  0/0  0/1  0/2  0/3
//  1/0  1/1  1/2  1/3
//  2/0  2/1  2/2  2/3
//  3/0  3/1  3/2  3/3
// 1. 判断是否属于同一列
// 2. 判断左边斜线上是否有冲突
//    *
//      *
//        *
// 2. 判断右边斜线上是否有冲突
//           *
//          *
//        *
func totalNQueens(n int) int {
    // 结果
    res := make([][]string, 0)
    // 初始化path
    path := make([]string, 0)
    for i := 0; i< n ; i++ {
        path = append(path, strings.Repeat(".", n))
    }
    // 从第一行开始
    row := 0

    backtrack(row, path, &res)

    return len(res)
}

func backtrack(row int, path []string, res *[][]string) {
    if len(path) == row {
        temp := make([]string, len(path))
        copy(temp, path)
        *res = append(*res, temp)
        return
    }

    n := len(path)
    for col := 0; col
        if !isConflict(path, row, col) {
            continue
        }

        rowBytes := []byte(path[row])
        rowBytes[col] = 'Q'
        path[row] = string(rowBytes)

        backtrack(row+1, path, res)

        rowBytes[col] = '.'
        path[row] = string(rowBytes)
    }
}

func isConflict(path []string, row, col int) bool {
    // 同一列
    n := len(path)
    for i := 0; i < n; i++ {
        if path[i][col] == 'Q' {
            return false
        }
    }

    // 左上方
    r := row-1
    c := col-1 
    for r >= 0 && c >= 0 {
        if path[r][c] == 'Q' {
            return false
        }
        c = c - 1
        r = r - 1
    }

    // 右上方
    r = row-1
    c = col+ 1
    for r >=0 && c < n {
        if path[r][c] == 'Q' {
            return false
        }
        c = c + 1
        r = r - 1
    }
    
    return true
}

goroutine池简单实现

2023-05-21T14:00:43.000Z

不可复用的简单实现

其实就是基于有缓冲channel的特性，每创建一个goroutine就向goroutine里面发送一个数据，goroutine任务完成之后就消费一条channel里面的数据，当channel满了之后就阻塞。

func main() {
// 最多50个goroutine
ch := make(chan struct{}, 100)
wg := sync.WaitGroup{}

for i := 0; i <= 1000; i++ {
ch <- struct{}{}
wg.Add(1)
go func(num int) {
defer func() {
wg.Done()
<-ch
}()
DoSomething(num)
}(i)
}
wg.Wait()
fmt.Println("Done")
}

func DoSomething(num int){
fmt.Printf("k....: %d \n", num)
time.Sleep(time.Second)
}

上面方案实现简单，但缺点是会不断创建和销毁goroutine，不可服用，性能较差。

可复用的pool

func main(){
jobParams := make([]JobParams, 0)
jobParams = append(jobParams,
JobParams{ "张三", 18},
JobParams{ "李斯", 28},
JobParams{ "赵武", 8},
JobParams{ "王二", 1},
JobParams{ "利好", 7},
JobParams{ "六七", 2},
JobParams{ "问候", 23},
)
jobParamsCh := make(chan JobParams, 1000)

wg := sync.WaitGroup{}

wg.Add(1)
go func() {
defer wg.Done()
workPool(2, jobParamsCh)
}()

wg.Add(1)
go func() {
defer wg.Done()
for _, v := range jobParams {
jobParamsCh <- v
}
}()

wg.Wait()
fmt.Println("Done...")
}

func workPool(size int, jobParamCh chan JobParams) {
wg := sync.WaitGroup{}

for i := 1; i<= size; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for {
select {
case params := <-jobParamCh:
Job(params)
time.Sleep(time.Second)
default:
fmt.Println("wait...")
}
}
}()
}
wg.Wait()
}


type JobParams struct {
UserName string
Age int
}

func Job(params JobParams) {
// doSomethings for example:
fmt.Printf("Hello, I'm %s and %d years old. \n", params.UserName, params.Age)
}

其实就在在每个goroutine里面去获取需要处理的参数，然后调用对应的逻辑函数逐个处理。

go容易忽视的黑坑系列1

2023-05-15T15:58:02.000Z

先看下面代码，是否有问题。

func main(){
   const sh = "zhang"
   fmt.Println(&sh, sh)

   var nl string = "san"
   fmt.Println(&nl, nl)
}

运行结果：

1
2
3

☁  test_all  go run main.go
# command-line-arguments
./main.go:7:14: cannot take the address of sh

在go中，不同于变量是在运行时分配内存空间，常量通常会被编译器在预处理阶段直接展开，作为指令数据使用，所以常量无法寻址。

单向channel关闭

只读channel不允许关闭

func main(){
ch := make(chan string, 1000)
ch <- "name"
RecvSim(ch)
}
func RecvSim(ch <- chan string) {
fmt.Println(<-ch)
close(ch)
}

1
2
3

☁  test_all  go run main.go
# command-line-arguments
./main.go:35:7: invalid operation: close(ch) (cannot close receive-only channel)

只写channel可以关闭

func main(){
ch := make(chan string, 1000)
SendSim(ch)
}

func SendSim(ch chan <- string) {
ch <- "zzz..."
close(ch)
}

判断下面代码输出的结果：
情况A:

type T struct {
ls []int
}

func foo(t T) {
t.ls[0] = 100
}

func main() {
t := T{
ls: []int{1,2,3},
}
foo(t)

fmt.Println(t.ls)
}

正确答案是：[100,2,3]

情况B:

type T struct {
ls []int
}

func foo(t T) {
t.ls = append(t.ls, 100)
t.ls[0] = 1000
}

func main() {
t := T{
ls: []int{1,2,3},
}
foo(t)

fmt.Println(t.ls)
}

正确答案：[1,2,3]

函数foo参数t虽然是传传递，但是复制后的参数t的ls字段最开始指向底层的数组是公用的，所以情况A修改了第一个元素的值也会影响到原来的变量；而情况B犹豫追加了一个元素，导致函数foo的参数t底层数据进行了重新内存分配，指向了新的底层数组，所以不会影响原来的值。

context.WithValue容易忽视的陷阱。

查看下面的代码，说出下面代码输出的结果：

func main() {
   ctx0 := context.Background()
   ctx := context.WithValue(ctx0, "name", "zhangliang")
   ctx = context.WithValue(ctx0, "age", 12)
   fmt.Println(ctx.Value("name"))
   fmt.Println(ctx.Value("age"))
}

正确结果是：

1
2
3

☁  test_all  go run main.go
<nil>
12

这是因为每组context只允许存储一对key-value，后面的age把前面的name覆盖了。正确写法是：

func main() {
ctx0 := context.Background()
ctx1 := context.WithValue(ctx0, "name", "zhangliang")
ctx2 := context.WithValue(ctx1, "age", 12)
fmt.Println(ctx2.Value("name"))
fmt.Println(ctx2.Value("age"))
}

输出：

1
2
3

☁  test_all  go run main.go
zhangliang
12

此时的ctx2结构如下：

二叉搜索树插入于删除操作

2023-03-26T13:33:50.000Z

概念

二叉排序树（Binary Sarech/Sort Tree）或者是一颗空树；或者是具有如下性质的二叉树：

(1) 若它的左子树不空，则 左子树 上所有结点的值 均小于 它的根结点的值；
(2) 若它的右子树不空，则 右子树 上所有结点的值 均大于 它的根结点的值；
(3) 它的 左、右子树又分别为二叉排序树 。

比如一下值: 8、3、10、1、6、14、4、7、13，构造BTS的过程如下：

存储结构

type Node struct {
    Value string
    Left *Node
    Right *Node
}

查找

// SearchBST 这里假设值都是int，不做异常预期判断了，咱们就简单理解算法即可
func SearchBST(targetNode *Node,value int) *Node {
// 如果根节点为nil， 则肯定不存在
if targetNode ==  nil {
return nil
}

if value == targetNode.Value.(int)  {
return targetNode
}

if value < targetNode.Value.(int) {
return SearchBST(targetNode.Left, value)
}

if value > targetNode.Value.(int) {
return SearchBST(targetNode.Right, value)
}

return nil
}

插入

func InsertBST(targetNode *Node, value int) {
if targetNode == nil {
targetNode.Value = value
return
}

if targetNode.Value.(int) == value {
return
}

if value < targetNode.Value.(int) {
// 如果当前节点不存在左子树，则将该目标节点作为当前节点的左子树
if targetNode.Left == nil {
targetNode.Left = &Node{
Value: value,
}

return
}

InsertBST(targetNode.Left, value)
}

if value > targetNode.Value.(int) {
// 如果当前节点不存在右子树，则将该目标节点作为当前节点的右子树
if targetNode.Right == nil {
targetNode.Right = &Node{
Value: value,
}

return
}
InsertBST(targetNode.Right, value)
}

return
}

删除

删除二叉搜索树的节点相对而言复杂一点，如果待删除的节点同时包含左右子树，删除后如何恢复搜索树是一个问题。

比如删除节点8，那么是选举3作为根节点还是10呢？所以就需要我们一点点去梳理：

如果删除的节点是叶子结点（即没有左右子树），那么直接删除即可，比如上面的1、7、9、13.
如果删除的节点只有左子树或者只有右子树，则删除后将子节点直接指向删除节点的位置即可，比如6、14

还有一种情况就是同时存在左右子树的情况，比如8，为了维持删除后的树依然符合二叉搜索树特性，其实可以将左子树的最大值或者右子树的最小值转移到删除点位置比如将7放在8的位置，但是这里的7是叶子结点，直接删除即可，如果7还包含左右子树，其实可以递归删除替换即可。我们可以用一个比较大的BST来举例：


func DeleteBST(node *Node, value int) *Node {
// 如果二叉搜索树为nil，则直接返回
if node == nil {
return nil
}

// 如果当前节点的值等于待删除值
if node.Value == value {
// 如果当前节点没有左右子树，则直接删除
if node.Left == nil && node.Right == nil {
node = nil
return node
}

// 只有右边子树，直接用右子树覆盖
if node.Left == nil {
node = node.Right
return node
}

// 只有左子树，直接用左子树覆盖
if node.Right == nil {
node = node.Left
return node
}

if node.Left != nil && node.Right != nil {
// 找到左子树中最大值，将其设置为当前的值
maxInLeft := FindMaxInNodeBST(node.Left)
node.Value = maxInLeft.Value
node.Left = DeleteBST(node.Left, maxInLeft.Value.(int))
return node
}

return node
}

// 有左子树，并且当前节点的值小于目标值，则进入左子树递归查找删除
if node.Left != nil && value < node.Value.(int)  {
node.Left =  DeleteBST(node.Left, value)
return node
}

// 有右子树，并且当前节点的值大于目标值，则进入右子树递归查找删除
if node.Right != nil && value > node.Value.(int) {
node.Right = DeleteBST(node.Right, value)
return node
}

return node
}

func FindMaxInNodeBST(node *Node) *Node {
if node == nil {
return nil
}

// 树中的最大值肯定在根节点或者右子树中

// 如果左右子树都为空，则就是当前节点
if node.Left == nil && node.Right == nil {
return node
}

二叉树遍历

2023-03-24T16:16:01.000Z

方式

概念

前序遍历：递归遍历根->左->右
中序遍历：递归遍历左->根->右
后续遍历：递归遍历左->右->中
层序遍历：由根节点开始一层层的遍历

其实前序遍历、中序遍历、后序遍历里面的前、中、后指的是根结点的位置。以下面这棵树来举例说明。

存储结构

type Node struct {
    Value string
    Left *Node
    Right *Node
}

前序遍历

前序遍历要求先遍历根节点，然后遍历左子树，左后便利右子树。注意这里指的是【子树】不是孩子。所以遍历顺序为：
A,B,D,H,I,E,J,C,F,K,G

func PreRange(node *Node) []string  {
if node == nil {
return nil
}
list := make([]string, 0)
list = append(list, node.Value)

leftList := PreRange(node.Left)
if leftList != nil {
list = append(list, leftList...)
}
rightList := PreRange(node.Right)
if rightList != nil {
list = append(list, rightList...)
}

return list
}

中序遍历

中序遍历要求先遍历左子树，然后遍历根节点，最后遍历右子树。所以顺序为：
H,D,I,B,E,J,A,F,K,C,G

func MidRange(node *Node) []string {
if node == nil {
return nil
}
list := make([]string,0)
leftList := MidRange(node.Left)
if leftList != nil {
list = append(list, leftList...)
}
list = append(list, node.Value)
rightList := MidRange(node.Right)
if rightList != nil {
list = append(list, rightList...)
}

return list
}

后续遍历

后序遍历要求先遍历左子树，然后遍历右子树，最后遍历根节点。所以顺序为：
H,I,D,J,E,B,K,F,G,C,A

func SufRange(node *Node) []string {
if node == nil {
return nil
}
list := make([]string,0)
leftList := SufRange(node.Left)
if leftList != nil {
list = append(list, leftList...)
}
rightList := SufRange(node.Right)
if rightList != nil {
list = append(list, rightList...)
}
list = append(list, node.Value)

return list
}

层序遍历

层序遍历其实就是从根节点开始从左到右一层层开始遍历所有节点，所以顺序为：
A,B,C,D,E,F,G,H,I,J,K


func LevelTraversal(node *Node) []string {
if node == nil {
return nil
}

nodeList := make([]*Node, 0)
nodeList = append(nodeList, node)

return RecursionTraversal(nodeList)
}

func RecursionTraversal(nodeList []*Node) []string {
if len(nodeList) == 0 {
return nil
}

list := make([]string,0)
nextNodeList := make([]*Node, 0)
for _, node := range nodeList {
list = append(list, node.Value)

if node.Left != nil {
nextNodeList = append(nextNodeList, node.Left)
}

if node.Right != nil {
nextNodeList =append(nextNodeList, node.Right)
}
}

if len(nextNodeList) > 0 {
s := RecursionTraversal(nextNodeList)
 if len(s) > 0 {
 list = append(list, s...)
 }
}

return list
}

分布式锁方案对比

2023-03-02T16:15:58.000Z

分布式锁

当我们对一份数据进行修改的时候需要先读取，再修改，由于读取和修改不是原子操作，在并发的情况下，无法保证前后数据是一致的，在单点服务中我们可以使用本地锁来实现（比如：sync.Mutex），但是对于分布式系统服务，本地锁却无能为力。这时候就需要使用分布式锁来保证数据的一致性。

很多应用场景是需要系统保证幂等性的（如api服务或消息消费者），并发情况下或消息重复很容易造成系统重入，那么分布式锁是保障幂等的一个重要手段。还有一种场景就是商城做抢购活动、司机抢单等场景需要使用分布式锁来防止出现“超卖”现象。

实现方案

基于数据库的唯一索引
基于redis的setnx
基于zookeeper

基于数据库

基于唯一索引

基于数据库的实现方式的核心思想是：在数据库中创建一个表，表中包含方法名（或者变量等）等字段，并在方法名字段上创建唯一索引，想要执行某个方法，就使用这个方法名向表中插入数据，成功插入则获取锁，执行完成后删除对应的行数据释放锁。

新建一张表

DROP TABLE IF EXISTS `method_lock`;
CREATE TABLE `method_lock` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `method_name` varchar(64) NOT NULL COMMENT '锁定的方法名',
  `desc` varchar(255) NOT NULL COMMENT '备注信息',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uidx_method_name` (`method_name`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='锁定中的方法';

核心就是利用唯一索引的不可重复插入的特性，来控制锁的获取是释放。

想要执行某个方法，就使用这个方法名向表中插入数据：

1	INSERT INTO method_lock (method_name, desc) VALUES ('methodName', '测试的methodName');

因为我们对method_name做了唯一性约束，这里如果有多个请求同时提交到数据库的话，数据库会保证只有一个操作可以成功，那么我们就可以认为操作成功的那个线程获得了该方法的锁，可以执行方法体内容。

成功插入则获取锁，执行完成后删除对应的行数据释放锁：

1	delete from method_lock where method_name ='methodName';

乐观锁

乐观锁在操作数据时非常乐观，认为别人不会同时修改数据。因此乐观锁不会上锁，只是在执行更新的时候判断一下在此期间别人是否修改了数据：如果别人修改了数据则放弃操作，否则执行操作。

乐观锁大多数是基于数据版本(version)的记录机制实现的。何谓数据版本号？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表添加一个 “version”字段来实现读取出数据时，将此版本号一同读出，之后更新时，对此版本号加1。在更新过程中，会对版本号进行比较，如果是一致的，没有发生改变，则会成功执行本次操作；如果版本号不一致，则会更新失败。其实也可以为使用表的updated_at字段记录每次更新的时间戳，使用时间戳作为version字段。

乐观锁的优点比较明显，由于在检测数据冲突时并不依赖数据库本身的锁机制，不会影响请求的性能，当产生并发且并发量较小的时候只有少部分请求会失败。缺点是需要对表的设计增加额外的字段，增加了数据库的冗余，另外，当应用并发量高的时候，version值在频繁变化，则会导致大量请求失败，影响系统的可用性。数据库锁都是作用于同一行数据记录上，这就导致一个明显的缺点，在一些特殊场景，如大促、秒杀等活动开展的时候，大量的请求同时请求同一条记录的行锁（update），会对数据库产生很大的写压力。所以综合数据库乐观锁的优缺点，乐观锁比较适合并发量不高，并且写操作不频繁的场景。

悲观锁

悲观锁在操作数据时比较悲观，认为别人会同时修改数据。因此操作数据时直接把数据锁住，直到操作完成后才会释放锁；上锁期间其他人不能修改数据。

要使用悲观锁，我们必须关闭mysql数据库的自动提交属性，因为MySQL默认使用autocommit模式，也就是说，当你执行一个更新操作后，MySQL会立刻将结果进行提交。set autocommit=0;

//0.开始事务
begin;/begin work;/start transaction; (三者选一就可以)
//1.查询出商品信息
select status from t_goods where id=1 for update;
//2.根据商品信息生成订单
insert into t_orders (id,goods_id) values (null,1);
//3.修改商品status为2
update t_goods set status=2;
//4.提交事务
commit;/commit work;

在悲观锁中，每一次行数据的访问都是独占的，只有当正在访问该行数据的请求事务提交以后，其他请求才能依次访问该数据，否则将阻塞等待锁的获取。悲观锁可以严格保证数据访问的安全。但是缺点也明显，即每次请求都会额外产生加锁的开销且未获取到锁的请求将会阻塞等待锁的获取，在高并发环境下，容易造成大量请求阻塞，影响系统可用性。另外，悲观锁使用不当还可能产生死锁的情况。

缺陷

因为是基于数据库实现的，数据库的可用性和性能将直接影响分布式锁的可用性及性能，所以，数据库需要双机部署、数据同步、主备切换；
不具备可重入的特性，因为同一个线程在释放锁之前，行数据一直存在，无法再次成功插入数据，所以，需要在表中新增一列，用于记录当前获取到锁的机器和线程信息，在再次获取锁的时候，先查询表中机器和线程信息是否和当前机器和线程相同，若相同则直接获取锁；
没有锁失效机制，因为有可能出现成功插入数据后，服务器宕机了，对应的数据没有被删除，当服务恢复后一直获取不到锁，所以，需要在表中新增一列，用于记录失效时间，并且需要有定时任务清除这些失效的数据；
不具备阻塞锁特性，获取不到锁直接返回失败，所以需要优化获取逻辑，循环多次去获取。
在实施的过程中会遇到各种不同的问题，为了解决这些问题，实现方式将会越来越复杂；依赖数据库需要一定的资源开销，性能问题需要考虑。

基于redis的setnx

获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。

Text

1 2	SETNX {ResourceURI} {UUID} EXPIRE {ResourceURI} {timeout}

释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。

Text

// 比对 value 与 标识
if (redis.get("lock:168").equals(random_value)){
   redis.del("lock:168"); //比对成功则删除
 }

缺陷

setnx和expire操作的非原子特性会导致死锁问题。协程A执行setnx命令成功，结果运行协程A的服务发生异常重启，导致expire命令没有执行，那么就会由于锁没有设置超时时间形成死锁。
A线程拿到锁超时释放，但是A依旧在执行自己的业务逻辑，此时B线程立刻获得锁，B也开始执行。这显然是不被允许的，一般会采取加大过期时间或者添加守护线程，go中也可以使用context设置过期时间。
上述方案无法达到不可重入，即在同一个协程中多次加锁。可以在本地维护一个map，map的key为锁标识，value为加锁次数。每次加锁的时候加1，重新设置过期时间，每次释放锁的时候减1，当计数小于或等于1的时候执行删除操作删除

基于zookeeper

利用zookeeper的临时有序节点和wathcer机制来实现分布式锁的功能。具体实现步骤如下：

创建一个目录lock
每个节点尝试获取锁时，首先在zookeeper的lock目录下创建一个znode节点，zookeeper的有序临时节点会自动根据创建先后顺序给节点编号。

判断当前服务节点创建的znode节点是最小节点。

如果序列号是最小的，则成功获取到锁。执行完操作后，把创建的节点给删掉。
如果不是，则监听比自己要小 1 的节点变化。直到拿到自己是最小的节点时获得锁。

缺陷

虽然zookeeper具备高可用、可重入、阻塞锁特性，可解决失效死锁问题，但是因为需要频繁的创建和删除节点，性能上不如Redis方式。

引用

小米技术团队-分布式锁的实现之 redis 篇

刘清政的博客-分布式锁

go高级编程-分布式锁

美团技术团队-缓存那些事