golang 实现单向链表（lru）、双向链表、双向循环链表

单向链表实现lru

package mainimport "fmt"func main() {// 实现一个lru 淘汰算法// linked 结构体// node 节点 ： data prev next// 更新lru// 如果没有满// 将新的数据加入到头结点// 队满 ： 删除尾结点// 将新数据加入头结点linkedObj := getLinked[int](5)linkedObj.insert(6)linkedObj.insert(5)linkedObj.insert(4)linkedObj.insert(3)linkedObj.insert(2)linkedObj.insert(1)linkedObj.insert(0)//fmt.Printf("当前节点: %+v\n", linkedObj)fmt.Printf("当前节点: %+v\n", linkedObj.head.next.data)linkedObj.foreach()
}type linked[T int | string | map[string]string] struct {head   *node[T]length intlimit  int
}type node[T int | string | map[string]string] struct {data Tnext *node[T]
}func getLinked[T int | string | map[string]string](limit int) *linked[T] {headNode := &node[T]{}return &linked[T]{head:   headNode,length: 0,limit:  limit,}
}func createNode[T int | string | map[string]string](data T) *node[T] {return &node[T]{data: data,next: nil,}
}func (l *linked[T]) insert(data T) bool {newNode := createNode(data)headNode := l.head.nextnewNode.next = l.head.nextl.head.next = newNodeif l.length == l.limit {prevNode := headNodefor headNode.next != nil {prevNode = headNodeheadNode = headNode.next}prevNode.next = nil} else {l.length++}return true
}func (l *linked[T]) foreach() {headNode := l.head.nextfor headNode.next != nil {headNode = headNode.nextfmt.Printf("当前节点: %+v\n", headNode.data)}
}

双向链表

package mainimport "fmt"func main() {// 实现一个双向循环链表linkedObj := getLinked[int](5)linkedObj.headInsert(6)linkedObj.headInsert(5)linkedObj.headInsert(4)linkedObj.headInsert(3)linkedObj.headInsert(2)linkedObj.headInsert(1)linkedObj.headInsert(0)//fmt.Printf("当前节点: %+v\n", linkedObj)//fmt.Printf("当前节点: %+v\n", linkedObj.head.next.data)linkedObj.headForeach()//linkedObj.tailForeach()
}type linked[T int | string | map[string]string] struct {head   *node[T]length intlimit  int
}type node[T int | string | map[string]string] struct {data Tnext *node[T]prev *node[T]
}func getLinked[T int | string | map[string]string](limit int) *linked[T] {return &linked[T]{head:   nil,length: 0,limit:  limit,}
}func createNode[T int | string | map[string]string](data T) *node[T] {return &node[T]{data: data,next: nil,prev: nil,}
}// 从头部插入
func (l *linked[T]) headInsert(data T) bool {newNode := createNode(data)if l.head == nil {l.head = newNodel.head.next = newNodel.head.prev = newNodel.length++return true}// 原头结点currentNode := l.headheadNode := currentNodel.head = newNodenewNode.next = currentNodecurrentNode.prev = newNode// 找到尾结点for {if currentNode.next == headNode {break}currentNode = currentNode.next}if l.length >= l.limit {currentNode.prev.next = l.headl.head.prev = currentNode.prev} else {l.head.prev = currentNodel.length++}return true
}func (l *linked[T]) delete(node *node[T]) {}// 从头部遍历
func (l *linked[T]) headForeach() {headNode := l.headfmt.Printf("从头结点遍历：\n")for {fmt.Printf("当前节点: %+v\n", headNode.data)if headNode.next == l.head {break}headNode = headNode.next}
}// 从尾部遍历
func (l *linked[T]) tailForeach() {endNode := l.head.prevfmt.Printf("从尾结点遍历：\n")for {fmt.Printf("当前节点: %+v\n", endNode.data)if endNode.prev == l.head.prev {break}endNode = endNode.prev}
}

双向循环链表

package mainimport "fmt"func main() {// 实现一个lru 淘汰算法// 双向循环链表// linked 结构体// node 节点 ： data prev next// 更新lru// 如果没有满// 将新的数据加入到头结点// 队满 ： 删除尾结点// 将新数据加入头结点linkedObj := getLinked[int](5)linkedObj.headInsert(6)linkedObj.headInsert(5)linkedObj.headInsert(4)linkedObj.headInsert(3)linkedObj.headInsert(2)linkedObj.headInsert(1)linkedObj.headInsert(0)//fmt.Printf("当前节点: %+v\n", linkedObj)//fmt.Printf("当前节点: %+v\n", linkedObj.head.next.data)linkedObj.headForeach()linkedObj.tailForeach()
}type linked[T int | string | map[string]string] struct {head   *node[T]length intlimit  int
}type node[T int | string | map[string]string] struct {data Tnext *node[T]prev *node[T]
}func getLinked[T int | string | map[string]string](limit int) *linked[T] {return &linked[T]{head:   nil,length: 0,limit:  limit,}
}func createNode[T int | string | map[string]string](data T) *node[T] {return &node[T]{data: data,next: nil,prev: nil,}
}// 从头部插入
func (l *linked[T]) headInsert(data T) bool {newNode := createNode(data)if l.head == nil {l.head = newNodel.length++newNode.next = newNodenewNode.prev = newNodereturn true}currentNode := l.head// 头结点位置headNodePos := l.headl.head = newNodenewNode.next = currentNodecurrentNode.prev = newNode// 找尾结点for {if currentNode.next == headNodePos {break}currentNode = currentNode.next}if l.length >= l.limit {currentNode.prev.next = newNodenewNode.prev = currentNode.prev} else {currentNode.next = newNodenewNode.prev = currentNodel.length++}return true
}func (l *linked[T]) delete(node *node[T]) {}// 从头部遍历
func (l *linked[T]) headForeach() {headNode := l.headheadNodPos := headNodefmt.Printf("从头结点遍历：\n")for {fmt.Printf("当前节点: %+v\n", headNode.data)if headNode.next == headNodPos {break}headNode = headNode.next}
}// 从尾部遍历
func (l *linked[T]) tailForeach() {endNode := l.headendNodePos := endNodefmt.Printf("从尾结点遍历：\n")for {fmt.Printf("当前节点: %+v\n", endNode.prev.data)if endNode.prev == endNodePos {break}endNode = endNode.prev}
}