独家封印解开：Go语言列表List操作大揭秘

// 定义一个最大长度为100的int列表
var list [100]int
// 加入两个元素 
list[0] = 1  
list[1] = 2
// 读取第一个元素
v := list[0]
// 遍历数组列表
for i := 0; i < len(list); i++ {
  v := list[i]
  fmt.Println(v) 
}

// 定义一个最大长度为3的字符串列表
var strList [3]string 
// 尾部追加元素
strList[0] = "foo"
strList[1] = "bar"
// 头部插入元素
strList[2] = strList[1]
strList[1] = "baz"
// 读取第2个元素
v := strList[1]
// 遍历列表
for i := 0; i < len(strList); i++ {
  fmt.Println(strList[i]) 
}
// 删除第1个元素
strList[1] = ""

// 定义一个字符串切片
var strList []string
// 尾部追加元素  
strList = append(strList, "foo")
strList = append(strList, "bar")
// 读取第一个元素
v := strList[0] 
// 遍历切片列表
for i := range strList {
  fmt.Println(strList[i])
}
// 删除第1个元素
strList = append(strList[:1], strList[2:]...) 

// 定义一个数值切片
var numList []float64
// 尾部添加元素
numList = append(numList, 1.2)
// 头部添加元素 
numList = append([]float64{2.3}, numList...)
// 中间位置添加元素
numList = append(numList[:1], append([]float64{3.4}, numList[1:]...)...)
// 读取第2个元素
v := numList[1] 
// 删除第1个元素
numList = append(numList[:1], numList[2:]...)

// 链表节点
type Node struct {
  Value int
  Next *Node
}
// 初始化一个空链表 
var list List
// 尾部插入元素
node := &Node{Value: 1}
list.Append(node)
node = &Node{Value: 2}
list.Append(node)  
// 读取第1个节点
node := list.Head.Next 
// 遍历链表
for n := list.Head; n != nil; n = n.Next {
  fmt.Println(n.Value)
}
// 删除第2个节点
list.Remove(node.Next) 

// 定义链表节点
type Node struct {
  Value int
  Next *Node
}
// 初始化链表
list := new(List)
// 头插法建立链表 
header := &Node{}
list.Append(header)
p := header
for i := 1; i <= 5; i++ {
  tmp := &Node{Value: i}
  p.Next = tmp
  p = tmp
}
// 尾插法插入元素 
tail := &Node{Value: 6}
p.Next = tail
// 删除第2个节点
list.Remove(header.Next.Next)
// 查找节点
n := list.Find(2)
// 反转链表
list.Reverse(header)
// 遍历链表
for n := header.Next; n != nil; n = n.Next {
  fmt.Println(n.Value)  
}

node := &Node{Value: v}
tail.Next = node 
tail = node

list = append([]int{v}, list...)

node := &Node{Value: v}
node.Next = head.Next
head.Next = node

list = append(list[:i], append([]int{v}, list[i:]...)...)

node := &Node{Value:v}
node.Next = p.Next 
p.Next = node

v := list[i]

import "sync"
// 定义一个互斥锁
var mutex sync.Mutex
// 加锁保护列表
mutex.Lock() 
list = append(list, v)
mutex.Unlock()
// 使用读写锁分别保护读写
var rw sync.RWMutex
rw.RLock()
v = list[0]  
rw.RUnlock()
rw.Lock()
list = append(list, v)  
rw.Unlock()

for i := 0; i < len(list); i++ {
  if list[i] == v {
    return i
  }
}
return -1 

func binarySearch(list []int, v int) int {
  // 二分查找算法
  return index 
}

for i := 0; i < len(list); i++ {
  reversed[len(list)-i-1] = list[i] 
}

var prev *Node
for cur := head.Next; cur != nil; {
  nxt := cur.Next
  cur.Next = prev
  prev = cur 
  cur = nxt
}
head.Next = prev

// 待办任务队列  
var taskQueue []*Task 
// 添加任务
taskQueue = append(taskQueue, NewTask(params))
// 获取执行任务  
task := taskQueue[0] 
taskQueue = taskQueue[1:]
// 已完成任务列表
var doneList []*Task

// 商品列表
var productList []*Product
// 添加商品
productList = append(productList, NewProduct(name, desc))
// 删除下架商品
for i := 0; i < len(productList); i++ {
  if !productList[i].OnSale {
    productList = append(productList[:i], productList[i+1:]...) 
  }
}

// 双向链表
type Node struct {
  Prev, Next *Node
  Key, Value interface{}
}
// Get时将节点移到表头  
lru.Evict(node)
lru.Add(node)
// 淘汰链表尾节点
tail := lru.tail 
lru.Remove(tail)