// 冒泡排序
func bubbleSort2(arr []int) []int {
	n, k, swapPos := len(arr), len(arr)-1, 0
	for i := 0; i < n; i++ {
		hasSort := true //  外循环，引入标志位
		for j := 0; j < k; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
				hasSort = false // 满足交换条件，更改标志位
				swapPos = j
			}
		}
		if hasSort { // 已经排序完，退出循环
			break
		}
		k = swapPos
	}
	return arr
}

// 鸡尾酒排序
func cocktailSort(arr []int) []int {
	var i int
	left, right := 0, len(arr)-1
	index := left // 临时变量
	// 判断数组中是否有多个元素
	for left < right {
		isSort := false                // 标志位，如果内循环没有发生交换元素，退出循环
		for i = left; i < right; i++ { // 从左往右扫描，找出较大的元素
			if arr[i] > arr[i+1] {
				arr[i], arr[i+1] = arr[i+1], arr[i]
				isSort = true
				index = i
			}
		}
		right = index
		for i = right; i > left; i++ { // 从右向左扫描，找出较小的元素
			if arr[i] < arr[i-1] {
				arr[i], arr[i-1] = arr[i-1], arr[i]
				isSort = true
				index = i
			}
		}
		left = index
		if !isSort {
			break
		}
	}
	return arr
}

// 开启事务
tx := db.Begin()

// 通过悲观锁语法锁住 id 为 1 的记录
tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where(&Goods{ID:1}).First(&user)

// 业务操作
...

// 遇到错误时回滚事务
tx.Rollback()

// 提交事务
tx.Commit()

for {
    // 强制更新 Stock、Version字段，并时Version + 1
    result := tx.Model(&model.Inventory{}).Select("Stocks", "Version").Where("goods = ? and version = ?", goodInfo.GoodsId, inv.Version).Updates(model.Inventory{Stocks: inv.Stocks, Version: inv.Version + 1})
    if result.RowAffected == 0 {
        // 更新失败重试
        log.Printf()("更新失败")
    } else {
        // 退出循环
        break
    }
}

package main

import (
	"github.com/go-redsync/redsync/v4"
	"github.com/go-redsync/redsync/v4/redis/goredis/v9"
	goredislib "github.com/redis/go-redis/v9"
)

func main() {
	// 连接redis
	client := goredislib.NewClient(&goredislib.Options{
		Addr: "localhost:6379",
	})
	pool := goredis.NewPool(client) // 新建连接池

	// 创建一个redsync实例，用来获取互斥锁
	rs := redsync.New(pool)

	// 创建命名互斥锁
	mutexname := "my-global-mutex"
	mutex := rs.NewMutex(mutexname)

	//获取给定互斥对象的锁。在此操作成功后，没有其他人可以获得相同的锁(相同的互斥锁名称)，直到我们解锁它
	if err := mutex.Lock(); err != nil {
		panic(err)
	}

	// 你的代码逻辑

	// 释放锁，以便其他进程或线程可以获得锁
	if ok, err := mutex.Unlock(); !ok || err != nil {
		panic("unlock failed")
	}
}

client := goredislib.NewClient(&goredislib.Options{
	Addr: "localhost:6379",
})
pool := goredis.NewPool(client) // 新建连接池

// 创建一个redsync实例，用来获取互斥锁
rs := redsync.New(pool)

// 创建命名互斥锁
mutexname := "<uuid + goodsId>"
mutex := rs.NewMutex(mutexname)
// 尝试获取锁，最多等待 2 秒
if err := mutex.LockEx(time.Second * 2); err != nil {
	fmt.Println("未能获得锁:", err)
	return
}
defer func() {
	// 通过 recover 捕获异常，确保释放锁
	if r := recover(); r != nil {
		fmt.Println("发生异常:", r)
	}
	mutex.Unlock()
}()

package main

import "fmt"

// GraphNode 定义图的结构
type GraphNode struct {
	value    int
	adjacent []*GraphNode
	visited  bool
}

func NewGraphNode(value int) *GraphNode {
	return &GraphNode{
		value:    value,
		adjacent: make([]*GraphNode, 0),
		visited:  false,
	}
}

func BFS(startNode *GraphNode) {
	var queue []*GraphNode           // 待访问的节点队列
	queue = append(queue, startNode) // 将初始节点加入队列
	startNode.visited = true         // 将初始节点设置为已访问

	for len(queue) > 0 {
		node := queue[0] // 出队一个节点，作为当前节点
		queue = queue[1:]
		fmt.Println("当前节点:", node.value)
		for _, graphNode := range node.adjacent {
			// (未访问过的)将相邻节点设置为已访问并加入队列
			if !graphNode.visited {
				graphNode.visited = true
				queue = append(queue, graphNode)
			}
		}
	}
}

func main() {
	// 创建图节点
	node1 := NewGraphNode(1)
	node2 := NewGraphNode(2)
	node3 := NewGraphNode(3)
	node4 := NewGraphNode(4)
	node5 := NewGraphNode(5)

	// 构建图的邻接关系
	node1.adjacent = append(node1.adjacent, node2, node3)
	node2.adjacent = append(node2.adjacent, node1, node4, node5)
	node3.adjacent = append(node3.adjacent, node1)
	node4.adjacent = append(node4.adjacent, node2)
	node5.adjacent = append(node5.adjacent, node2)

	// 从节点1开始进行BFS
	BFS(node1)
}

func quickSort(arr []int, low, high int) []int {
	if low < high {
		pivotIndex := partition(arr, low, high)
		quickSort(arr, low, pivotIndex-1)
		quickSort(arr, pivotIndex+1, high)
	}
	return arr
}

func partition(arr []int, low, high int) int {
	i := low
	pivot := arr[high]
	for j := i; j < high; j++ {
		if arr[j] <= pivot {
			arr[j], arr[i] = arr[i], arr[j]
			i++
		}
	}
	arr[i], arr[high] = arr[high], arr[i]
	return i
}

func search(nums []int,target int) int {
    left,right := 0,len(nums) - 1
    for left <= right { 
        mid := (left + right)/2
        num := nums[mid]
        if target == num {
            return mid
        } else if target > num {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return -1
}

package main

import "fmt"

// LRUCache 最近最少使用
type LRUCache struct {
	size       int
	capacity   int
	cache      map[int]*DoubleLinkNode
	head, tail *DoubleLinkNode
}

// DoubleLinkNode 双向链表
type DoubleLinkNode struct {
	key, value int
	prev, next *DoubleLinkNode
}

// 初始化双向链表
func initDoubleLinkNode(key, value int) *DoubleLinkNode {
	return &DoubleLinkNode{
		key:   key,
		value: value,
	}
}

// Constructor 初始化LRU缓存
func Constructor(capacity int) LRUCache {
	l := LRUCache{
		capacity: capacity,
		cache:    map[int]*DoubleLinkNode{},
		head:     initDoubleLinkNode(0, 0),
		tail:     initDoubleLinkNode(0, 0),
	}
	l.head.next = l.tail
	l.tail.prev = l.head
	return l
}

func (l *LRUCache) Get(key int) int {
	if _, ok := l.cache[key]; !ok {
		return -1
	}
	node := l.cache[key]
	l.moveToHead(node)
	return node.value
}

func (l *LRUCache) Put(key, value int) {
	// 新增元素 放在链表头部
	if _, ok := l.cache[key]; !ok {
		node := initDoubleLinkNode(key, value)
		l.cache[key] = node
		l.addToHead(node)
		l.size++
		// 超出容量 删除最后一个元素
		if l.size > l.capacity {
			removed := l.removeTail()
			delete(l.cache, removed.key)
			l.size--
		}
	} else {
		// 更新元素 放在链表头部
		node := l.cache[key]
		node.value = value
		l.moveToHead(node)
	}
}

func (l *LRUCache) addToHead(node *DoubleLinkNode) {
	node.prev = l.head
	node.next = l.head.next
	l.head.next.prev = node
	l.head.next = node
}

func (l *LRUCache) removeNode(node *DoubleLinkNode) {
	node.prev.next = node.next
	node.next.prev = node.prev
}

func (l *LRUCache) moveToHead(node *DoubleLinkNode) {
	l.removeNode(node)
	l.addToHead(node)
}

func (l *LRUCache) removeTail() *DoubleLinkNode {
	node := l.tail.prev
	l.removeNode(node)
	return node
}

func main() {
	cache := Constructor(2)

	cache.Put(1, 1)
	cache.Put(2, 2)

	fmt.Println(cache.Get(1)) //删除2 输出 1

	cache.Put(3, 3)

	fmt.Println(cache.Get(2)) // 输出 -1

	cache.Put(4, 4) // 删除 1

	fmt.Println(cache.Get(1)) // 输出 -1
	fmt.Println(cache.Get(3)) // 输出 3
	fmt.Println(cache.Get(4)) // 输出 4
}

package main

import "fmt"

// LFUCache 最不经常使用
type LFUCache struct {
	size     int // 大小
	capacity int // 容量
	minFreq  int // 最小访问次数
	cache    map[int]*Node
	freq     map[int]*DLinkedList
}

type Node struct {
	key        int
	value      int
	freq       int // 访问次数
	prev, next *Node
}

// DLinkedList 访问次数为n的元素组成的双向链表（LRU特性）
type DLinkedList struct {
	head, tail *Node
}

func Constructor(capacity int) LFUCache {
	return LFUCache{
		capacity: capacity,
		cache:    make(map[int]*Node),
		freq:     make(map[int]*DLinkedList),
	}
}

func InitDLinkedList() *DLinkedList {
	head, tail := &Node{}, &Node{}
	head.next = tail
	tail.prev = head
	return &DLinkedList{
		head: head,
		tail: tail,
	}
}

func (d *DLinkedList) AddToHead(node *Node) {
	node.prev = d.head
	node.next = d.head.next

	d.head.next.prev = node
	d.head.next = node
}

func (d *DLinkedList) Remove(node *Node) {
	node.prev.next = node.next
	node.next.prev = node.prev

	node.prev = nil
	node.next = nil
}

func (d *DLinkedList) RemoveTail() *Node {
	// 空链表
	if d.IsEmpty() {
		return nil
	}
	last := d.tail.prev
	d.Remove(last)
	return last
}

func (d *DLinkedList) IsEmpty() bool {
	return d.head.next == d.tail
}

func (l *LFUCache) Get(key int) int {
	if node, ok := l.cache[key]; ok {
		l.addFreq(node)
		return node.value
	}
	return -1
}

func (l *LFUCache) Put(key, value int) {
	if l.capacity == 0 {
		return
	}
	// 更新
	if node, ok := l.cache[key]; ok {
		node.value = value
		l.addFreq(node)
	} else {
		// 超出容量，删除访问次数最低的对应数据链表的最旧的元素
		if l.size >= l.capacity {
			node := l.freq[l.minFreq].RemoveTail()
			delete(l.cache, node.key)
			l.size--
		}
		node := &Node{key: key, value: value, freq: 1}
		l.cache[key] = node // 储存新节点

		if l.freq[1] == nil {
			l.freq[1] = InitDLinkedList()
		}
		l.freq[1].AddToHead(node)

		l.minFreq = 1
		l.size++
	}
}

func (l *LFUCache) addFreq(node *Node) {
	n := node.freq
	l.freq[n].Remove(node)

	if l.minFreq == n && l.freq[n].IsEmpty() {
		l.minFreq++
		delete(l.freq, n)
	}

	node.freq++
	if l.freq[node.freq] == nil {
		l.freq[node.freq] = InitDLinkedList()
	}
	l.freq[node.freq].AddToHead(node)
}

func main() {
	cache := Constructor(2)
	cache.Put(1, 1)
	cache.Put(2, 2)

	fmt.Println(cache.Get(1)) // 1
	cache.Put(3, 3)           // 删除2

	fmt.Println(cache.Get(2)) // -1
	fmt.Println(cache.Get(3)) // 3

	cache.Put(4, 4) // key2被淘汰

	fmt.Println(cache.Get(1)) // -1
	fmt.Println(cache.Get(3)) // 3
	fmt.Println(cache.Get(4)) // 4
}