package main
import"fmt"// Stack structure using a slicetype Stack struct{
items []int}// Push an item onto the stackfunc(s *Stack)Push(item int){
s.items =append(s.items, item)}// Pop an item from the stackfunc(s *Stack)Pop()int{iflen(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
}funcmain(){
stack := Stack{}
stack.Push(1)
stack.Push(2)
fmt.Println(stack.Pop())// 2
fmt.Println(stack.Pop())// 1}
2. 队列(Queue)
package main
import"fmt"// Queue structure using a slicetype Queue struct{
items []int}// Enqueue an item to the queuefunc(q *Queue)Enqueue(item int){
q.items =append(q.items, item)}// Dequeue an item from the queuefunc(q *Queue)Dequeue()int{iflen(q.items)==0{return-1// Queue is empty}
front := q.items[0]
q.items = q.items[1:]return front
}funcmain(){
queue := Queue{}
queue.Enqueue(1)
queue.Enqueue(2)
fmt.Println(queue.Dequeue())// 1
fmt.Println(queue.Dequeue())// 2}
3. 链表(LinkedList)
package main
import"fmt"// Node represents a node in the linked listtype Node struct{
value int
next *Node
}// LinkedList structuretype LinkedList struct{
head *Node
}// Insert a value at the end of the linked listfunc(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 listfunc(l *LinkedList)Print(){
current := l.head
for current !=nil{
fmt.Print(current.value," -> ")
current = current.next
}
fmt.Println("nil")}funcmain(){
list := LinkedList{}
list.Insert(1)
list.Insert(2)
list.Insert(3)
list.Print()// 1 -> 2 -> 3 -> nil}
4. 二叉树(Binary Tree)
package main
import"fmt"// TreeNode represents a node in the binary treetype TreeNode struct{
value int
left *TreeNode
right *TreeNode
}// BinaryTree structuretype BinaryTree struct{
root *TreeNode
}// Insert a value in the binary treefunc(t *BinaryTree)Insert(value int){if t.root ==nil{
t.root =&TreeNode{value: value}}else{insertNode(t.root, value)}}funcinsertNode(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 treefunc(t *BinaryTree)InOrder(){inOrderTraversal(t.root)}funcinOrderTraversal(node *TreeNode){if node !=nil{inOrderTraversal(node.left)
fmt.Print(node.value," ")inOrderTraversal(node.right)}}funcmain(){
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)
package main
import"fmt"// HashMap structure using a maptype HashMap struct{
items map[string]int}// Initialize a new hash mapfunc(h *HashMap)Init(){
h.items =make(map[string]int)}// Insert a key-value pair into the hash mapfunc(h *HashMap)Insert(key string, value int){
h.items[key]= value
}// Get a value by key from the hash mapfunc(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 mapfunc(h *HashMap)Delete(key string){delete(h.items, key)}funcmain(){
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}