---

数据结构与算法

链表

---手写单链表
type Node struct {
	Info int
	Next *Node
}

type List struct {
	Head *Node
	Len  int
	Tail *Node
}

func (list *List) Add(ele int) {
	node := &Node{Info: ele, Next: nil}
	if list.Len == 0 {
		list.Head = node
		list.Tail = node //尾指针
	} else {
		// head:=list.Head
		// for i:=1;i<list.Len;i++{
		// 	head = head.Next
		// }
		list.Tail.Next = node
		list.Tail = node
	}
	list.Len += 1
}

func (list List) Travs() {
	if list.Len == 0 {
		return
	}
	head := list.Head
	fmt.Printf("%d ", head.Info)
	for i := 1; i < list.Len; i++ {
		head = head.Next
		fmt.Printf("%d ", head.Info)
	}
}

  链表的一个应用案例。LRU(Least Recently Used, 最近最少使用)缓存淘汰的总体思路：缓存的key放到链表中，头部的元素表示最近刚使用。

• 如果命中缓存，从链表中找到对应的key，移到链表头部。

• 如果没命中缓存：

  • 如果缓存容量没超，放入缓存，并把key放到链表头部。

  • 如果超出缓存容量，删除链表尾部元素，再把key放到链表头部。

  • 基于手写双链表粗略实现LRU算法

  ---基于双链表实现LRU算法（TODO：往链表中添加元素时的判断）
  type Node struct {
  	Info int
  	Next *Node
  	Prev *Node
  }
  
  type List struct {
  	Head *Node
  	Len  int
  	Tail *Node
  }
  
  func (list *List) Add(ele int) {
  	node := &Node{Info: ele, Next: nil, Prev: nil}
  	if list.Len == 0 {
  		list.Head = node
  		list.Tail = node //尾指针
  	} else {
  		list.Tail.Next = node
  		node.Prev = list.Tail
  		list.Tail = node
  	}
  	list.Len += 1
  }
  
  func (list List) Travs() {
  	if list.Len == 0 {
  		return
  	}
  	head := list.Head
  	fmt.Printf("%d ", head.Info)
  	for i := 1; i < list.Len; i++ {
  		head = head.Next
  		fmt.Printf("%d ", head.Info)
  	}
  	fmt.Println()
  }
  
  func (list *List) Visit(ele int) {
  	if list.Len == 0 {
  		return
  	}
  	head := list.Head
  	for {
  		if head == nil {
  			break
  		}
  		if head.Info != ele {
  			head = head.Next
  		} else {
  			break
  		}
  	}
  	if head == nil {
  		return
  	} else { // 1-->8-->7-->5  改为7-->1-->8-->5
  		post := head.Next //5
  		pre := head.Prev  //8
  
  		pre.Next = post //8-->5
  		post.Prev = pre //5-->8
  
  		head.Next = list.Head // 7-->1
  		list.Head.Prev = head // 1-->7
  		list.Head = head      //7成链表的头部
  	}
  }
  
  

go list的使用

type Element

type Element struct {
    // 元素保管的值
    Value interface{}
    // 内含隐藏或非导出字段
}

Element类型代表是双向链表的一个元素。

---

func (*Element) Next

func (e *Element) Next() *Element

Next返回链表的后一个元素或者nil。

---

func (*Element) Prev

func (e *Element) Prev() *Element

Prev返回链表的前一个元素或者nil。

---

type List

type List struct {
    // 内含隐藏或非导出字段
}

List代表一个双向链表。List零值为一个空的、可用的链表。

---

func New

func New() *List

New创建一个链表。

---

func (*List) Init

func (l *List) Init() *List

Init清空链表。

---

func (*List) Len

func (l *List) Len() int

Len返回链表中元素的个数，复杂度O(1)。

---

func (*List) Front

func (l *List) Front() *Element

Front返回链表第一个元素或nil。

---

func (*List) Back

func (l *List) Back() *Element

Back返回链表最后一个元素或nil。

---

func (*List) PushFront

func (l *List) PushFront(v interface{}) *Element

PushBack将一个值为v的新元素插入链表的第一个位置，返回生成的新元素。

---

func (*List) PushFrontList

func (l *List) PushFrontList(other *List)

PushFrontList创建链表other的拷贝，并将拷贝的最后一个位置连接到链表l的第一个位置。

func (*List) PushBack

func (l *List) PushBack(v interface{}) *Element

PushBack将一个值为v的新元素插入链表的最后一个位置，返回生成的新元素。

---

func (*List) PushBackList

func (l *List) PushBackList(other *List)

PushBack创建链表other的拷贝，并将链表l的最后一个位置连接到拷贝的第一个位置。

---

func (*List) InsertBefore

func (l *List) InsertBefore(v interface{}, mark *Element) *Element

InsertBefore将一个值为v的新元素插入到mark前面，并返回生成的新元素。如果mark不是l的元素，l不会被修改。

---

func (*List) InsertAfter

func (l *List) InsertAfter(v interface{}, mark *Element) *Element

InsertAfter将一个值为v的新元素插入到mark后面，并返回新生成的元素。如果mark不是l的元素，l不会被修改。

---

func (*List) MoveToFront

func (l *List) MoveToFront(e *Element)

MoveToFront将元素e移动到链表的第一个位置，如果e不是l的元素，l不会被修改。

---

func (*List) MoveToBack

func (l *List) MoveToBack(e *Element)

MoveToBack将元素e移动到链表的最后一个位置，如果e不是l的元素，l不会被修改。

---

func (*List) MoveBefore

func (l *List) MoveBefore(e, mark *Element)

MoveBefore将元素e移动到mark的前面。如果e或mark不是l的元素，或者e==mark，l不会被修改。

---

func (*List) MoveAfter

func (l *List) MoveAfter(e, mark *Element)

MoveAfter将元素e移动到mark的后面。如果e或mark不是l的元素，或者e==mark，l不会被修改。

func (*List) Remove

func (l *List) Remove(e *Element) interface{}

Remove删除链表中的元素e，并返回e.Value。

	lst := list.New() // 创建一个空的双向链表
	lst.PushBack(4)
	lst.PushBack(6)
	lst.PushBack(2)
	lst.PushFront(9)//往链表头部添加
	TravsList(lst)// 9 4 6 2

func TravsList(lst *list.List) {
	head := lst.Front()
	for head.Next() != nil {
		fmt.Printf("%v ", head.Value)
		head = head.Next()
	}
	fmt.Printf("%v \n", head.Value)
}

  ring的应用：基于滑动窗口的统计。比如最近100次接口调用的平均耗时、最近10笔订单的平均值、最近30个交易日股票的最高点。ring的容量即为滑动窗口的大小，把待观察变量按时间顺序不停地写入ring即可。

package main

import (
	"container/ring"
	"fmt"
)

func TraverseRing(ring *ring.Ring) {
	ring.Do(func(i interface{}) { //通过Do()来遍历ring，内部实际上调用了Next()而非Prev()
		fmt.Printf("%v ", i)
	})
	fmt.Println()
}

func main() {
	ring := ring.New(5) //必须指定长度，各元素被初始化为nil
	ring2 := ring.Prev()
	for i := 0; i < 3; i++ {
		ring.Value = i
		ring = ring.Next()
	}
	for i := 0; i < 3; i++ {
		ring2.Value = i
		ring2 = ring2.Prev()
	}
	TraverseRing(ring)
	TraverseRing(ring2) //ring和ring2当前所在的指针位置不同，所以遍历出来的顺序也不同
}

栈

  栈是一种先进后出的数据结构，push把元素压入栈底，pop弹出栈顶的元素。编程语言的编译系统也用到了栈的思想。

  go自带的List已经包含了栈的功能，这里实现一个线程安全的栈。

type (
	node struct {
		value interface{}
		prev  *node
	}
	MyStack struct {
		top    *node
		length int
		lock   *sync.RWMutex
	}
)

func NewMyStack() *MyStack {
	return &MyStack{nil, 0, &sync.RWMutex{}}
}

func (stack *MyStack) Push(value interface{}) {
	stack.lock.Lock()
	defer stack.lock.Unlock()
	n := &node{value, stack.top}
	stack.top = n
	stack.length++
}

func (stack *MyStack) Pop() interface{} {
	stack.lock.Lock()
	defer stack.lock.Unlock()
	if stack.length == 0 {
		return nil
	}
	n := stack.top
	stack.top = n.prev
	stack.length--
	return n.value
}

func (stack *MyStack) Peak() interface{} {
	stack.lock.RLock()
	defer stack.lock.RUnlock()
	if stack.length == 0 {
		return nil
	}
	return stack.top.value
}

func (stack *MyStack) Len() int {
	return stack.length
}

func (stack *MyStack) Empty() bool {
	return stack.Len() == 0
}