package main
import "fmt"
// Stack structure using a slice
type Stack struct {
items []int
}
// Push an item onto the stack
func (s *Stack) Push(item int) {
s.items = append(s.items, item)
}
// Pop an item from the stack
func (s *Stack) Pop() int {
if len(s.items) == 0 {
return -1 // Stack is empty
}
top := s.items[len(s.items)-1]
s.items = s.items[:len(s.items)-1]
return top
}
func main() {
stack := Stack{}
stack.Push(1)
stack.Push(2)
fmt.Println(stack.Pop()) // 2
fmt.Println(stack.Pop()) // 1
}
2. 队列（Queue）
go复制代码
package main
import "fmt"
// Queue structure using a slice
type Queue struct {
items []int
}
// Enqueue an item to the queue
func (q *Queue) Enqueue(item int) {
q.items = append(q.items, item)
}
// Dequeue an item from the queue
func (q *Queue) Dequeue() int {
if len(q.items) == 0 {
return -1 // Queue is empty
}
front := q.items[0]
q.items = q.items[1:]
return front
}
func main() {
queue := Queue{}
queue.Enqueue(1)
queue.Enqueue(2)
fmt.Println(queue.Dequeue()) // 1
fmt.Println(queue.Dequeue()) // 2
}
3. 链表（LinkedList）
go复制代码
package main
import "fmt"
// Node represents a node in the linked list
type Node struct {
value int
next *Node
}
// LinkedList structure
type LinkedList struct {
head *Node
}
// Insert a value at the end of the linked list
func (l *LinkedList) Insert(value int) {
newNode := &Node{value: value}
if l.head == nil {
l.head = newNode
} else {
current := l.head
for current.next != nil {
current = current.next
}
current.next = newNode
}
}
// Print the linked list
func (l *LinkedList) Print() {
current := l.head
for current != nil {
fmt.Print(current.value, " -> ")
current = current.next
}
fmt.Println("nil")
}
func main() {
list := LinkedList{}
list.Insert(1)
list.Insert(2)
list.Insert(3)
list.Print() // 1 -> 2 -> 3 -> nil
}
4. 二叉树（Binary Tree）
go复制代码
package main
import "fmt"
// TreeNode represents a node in the binary tree
type TreeNode struct {
value int
left *TreeNode
right *TreeNode
}
// BinaryTree structure
type BinaryTree struct {
root *TreeNode
}
// Insert a value in the binary tree
func (t *BinaryTree) Insert(value int) {
if t.root == nil {
t.root = &TreeNode{value: value}
} else {
insertNode(t.root, value)
}
}
func insertNode(node *TreeNode, value int) {
if value < node.value {
if node.left == nil {
node.left = &TreeNode{value: value}
} else {
insertNode(node.left, value)
}
} else {
if node.right == nil {
node.right = &TreeNode{value: value}
} else {
insertNode(node.right, value)
}
}
}
// InOrder traversal of the binary tree
func (t *BinaryTree) InOrder() {
inOrderTraversal(t.root)
}
func inOrderTraversal(node *TreeNode) {
if node != nil {
inOrderTraversal(node.left)
fmt.Print(node.value, " ")
inOrderTraversal(node.right)
}
}
func main() {
tree := BinaryTree{}
tree.Insert(5)
tree.Insert(3)
tree.Insert(7)
tree.Insert(2)
tree.Insert(4)
tree.InOrder() // 2 3 4 5 7
}
5. 散列表（HashMap）
go复制代码
package main
import "fmt"
// HashMap structure using a map
type HashMap struct {
items map[string]int
}
// Initialize a new hash map
func (h *HashMap) Init() {
h.items = make(map[string]int)
}
// Insert a key-value pair into the hash map
func (h *HashMap) Insert(key string, value int) {
h.items[key] = value
}
// Get a value by key from the hash map
func (h *HashMap) Get(key string) int {
if value, found := h.items[key]; found {
return value
}
return -1 // Key not found
}
// Delete a key-value pair from the hash map
func (h *HashMap) Delete(key string) {
delete(h.items, key)
}
func main() {
hashMap := HashMap{}
hashMap.Init()
hashMap.Insert("a", 1)
hashMap.Insert("b", 2)
fmt.Println(hashMap.Get("a")) // 1
fmt.Println(hashMap.Get("b")) // 2
hashMap.Delete("a")
fmt.Println(hashMap.Get("a")) // -1
}