实现常用数据结构

队列

package main

import (
	"fmt"
	"sync"
)

type Queue struct {
	sync.Mutex
	data []any
}

func (q *Queue) Put(data any) {
	q.Lock()
	defer q.Unlock()
	q.data = append(q.data, data)
}

func (q *Queue) Get() (any, bool) {
	q.Lock()
	defer q.Unlock()
	if len(q.data) == 0 {
		return nil, false
	}
	data := q.data[0]
	q.data = q.data[1:]
	return data, true
}

func main() {
	q := &Queue{}
	q.Put("123")
	q.Put(nil)
	q.Put(3)

	fmt.Println(q.Get())
	fmt.Println(q.Get())
	fmt.Println(q.Get())
	fmt.Println(q.Get())

}

栈

package main

import (
	"fmt"
	"sync"
)

type Stack struct {
	sync.Mutex
	data []any
}

func (q *Stack) Put(data any) {
	q.Lock()
	defer q.Unlock()
	q.data = append([]any{data}, q.data...)
}

func (q *Stack) Get() (any, bool) {
	q.Lock()
	defer q.Unlock()
	if len(q.data) == 0 {
		return nil, false
	}
	data := q.data[0]
	q.data = q.data[1:]
	return data, true
}

func main() {
	q := &Stack{}
	q.Put("123")
	q.Put(nil)
	q.Put(3)

	fmt.Println(q.Get())
	fmt.Println(q.Get())
	fmt.Println(q.Get())
	fmt.Println(q.Get())

}

链表

package main

import (
	"fmt"
)

type LinkNode struct {
	no   uint64
	data any
	Next *LinkNode
	tail bool
}

func (n LinkNode) Data() any {
	return n.data
}

// LinkedList 结构体表示链表
type LinkedList struct {
	Head *LinkNode // 指向链表头部的指针
}

// Append 在链表末尾添加一个节点
func (list *LinkedList) Append(data any) {
	newNode := &LinkNode{data: data, Next: nil}

	// 如果链表为空，将新节点设置为头部
	if list.Head == nil {
		list.Head = newNode
		return
	}
	// 找到链表末尾，并将新节点链接到末尾
	lastNode := list.Head
	for lastNode.Next != nil {
		lastNode = lastNode.Next
	}
	lastNode.Next = newNode
}

// Display 打印链表的所有节点
func (list *LinkedList) Display() {
	current := list.Head

	for current != nil {
		fmt.Printf("%v -> ", current.Data())
		current = current.Next
	}
	fmt.Println("nil")
}

func (list *LinkedList) Get(index int) (any, bool) {

	if list.Head == nil {
		return nil, false
	}
	current := list.Head
	for i := 0; i < index; i++ {
		current = current.Next
		if current == nil {
			return nil, false
		}
	}
	return current.Data(), true
}

func (list *LinkedList) Len() (count int) {
	if list.Head == nil {
		return
	}
	current := list.Head
	for {
		count++
		current = current.Next
		if current == nil {
			break
		}
	}
	return
}

func (list *LinkedList) Insert(index int, data any) *LinkNode {
	newNode := &LinkNode{data: data, Next: nil}

	if list.Head == nil {
		list.Head = newNode
		return newNode
	}

	current := list.Head
	last := list.Head
	for i := 0; i < index; i++ {
		last = current
		current = current.Next
	}
	newNode.Next = current
	if index == 0 {
		list.Head = newNode
		return newNode
	}
	last.Next = newNode

	return newNode
}

func (list *LinkedList) SafeInsert(index int, data any) *LinkNode {
	lenth := list.Len()
	if index > lenth {
		index = lenth
	}
	return list.Insert(index, data)
}

func main() {
	// 创建一个新的链表
	myLinkedList := &LinkedList{}

	// 向链表中添加节点
	myLinkedList.Append(1)
	myLinkedList.Append(2)
	myLinkedList.Append(nil)
	myLinkedList.Append(3)
	myLinkedList.Append(4)

	// 打印链表
	myLinkedList.Display()

	// 取到链表中的第 N 个元素
	data, _ := myLinkedList.Get(0)
	fmt.Println("index 0:", data)

	myLinkedList.SafeInsert(6, 0)
	myLinkedList.Display()
	data, _ = myLinkedList.Get(2)
	fmt.Println("index 2:", data)
}