算法总结（Go语言）

主要是Go语言各种算法、数据结构的使用。

切片

var a = []int{
   1, 2, 3, 4}
a = append(a, 5)  // 在后面添加
b := a[:len(a)-1]  // 删除最后一个,并把最后一个返回给b
c := append(a[0:2], a[3:]...)  // 删除中间元素

链表

type Node struct {
   
	Data int
	Next *Node
}
type List struct {
   
	headNode *Node
}

// IsEmpty 判断链表是否为空
func (this *List) IsEmpty() bool {
   
	if this.headNode == nil {
   
		return true
	} else {
   
		return false
	}
}

// Length 获得链表长度
func (this *List) Length() int {
   
	cur := this.headNode
	count := 0
	for cur != nil {
   
		count++
		cur = cur.Next
	}
	return count
}

// Add 在链表头部添加元素
func (this *List) Add(data int) {
   
	node := &Node{
   Data: data}
	node.Next = this.headNode
	this.headNode = node
	return
}

// Append 在链表尾部添加元素
func (this *List) Append(data int) {
   
	node := &Node{
   Data: data}
	if this.IsEmpty() {
   
		this.headNode = node
	} else {
   
		cur := this.headNode
		for cur.Next != nil {
   
			cur = cur.Next
		}
		cur.Next = node
	}
}

// Insert 在某个位置插入
func (this *List) Insert(index int, data int) {
   
	if index < 0 {
   
		this.Add(data)
	} else if index > this.Length() {
   
		this.Append(data)
	} else {
   
		count := 0
		cur := this.headNode
		for count < (index - 1) {
   
			cur = cur.Next
			count++
		}
		node := &Node{
   Data: data}
		node.Next = cur.Next
		cur.Next = node
	}
}

栈

var a = []int{
   1,2}
// 入栈
a = append(a,3)
// 出栈
b := a[len(a)-1]
a = a[:len(a)-1]

队列

var queue = []int{
   1,2}
// 入队
queue = append(0,queue)
// 出队
r := queue[len(queue)-1]
queue = queue[len(queue)-1]

双端队列

var queue = []int{
   1,2}
// 左入队
queue = append(0,queue)
// 右入队
queue = append(queue,3)
// 右出队
r := queue[len(queue)-1]
queue = queue[:len(queue)-1]
// 左出队
r := queue[0]
queue = queue[1:]

哈希表和映射

var dic = map[string]int{
   'a': 12, 'b': 23}
dic['c'] = 34 //添加
if value,ok := dic['a'];ok==true{
   
	data = value //获得，如果不存在则不赋值
}
delete(dic, 'a') //删除

集合（用map实现）

hashSet := make(map[string]struct{
   }) //初始化
data := []string{
   "Hello", "World", "213", "3213", "213", "World"}
for _,v := range data{
   
	hashSet[v] = struct{
   }{
   }  //添加
}
for k,_ := range hashSet{
   
	fmt.Println(k)  //打印
}
delete(hashSet, "Hello")  //删除

单调栈

此类问题可以在左右两边加入哨兵，比如柱状图中最大的矩形这道题。

func largestRectangleArea() int {
   
    heights := []int{
   2,1,5,6,2,3}
    // 单调递增栈
    ans := 0
    heights = append([]int{
   0},heights...) // 加入左哨兵
    heights = append(heights,[]int{
   0}...) // 加入右哨兵
    stack := []int{
   0} // 栈，左哨兵入栈
    for i:=1;i<len(heights);i++{
   
        for heights[i] < heights[stack[len(stack)-1]]{
   
            // 出栈
            popi := stack[len(stack)-1]
            stack = stack[:len(stack)-1