Learn to use common data structures and their methods in Go language

To master common data structures and their usage in Go language, specific code examples are required

In Go language, data structure is a way to organize and store data. Way. Mastering common data structures and how to use them is crucial to developing efficient programs. This article will introduce common data structures in Go language and provide specific code examples.

1. Array (Array)
   An array is a data structure that stores fixed-size elements. In Go language, the length of arrays is immutable.

Code example:

package main

import "fmt"

func main() {
    // 创建一个长度为5的整数数组
    var arr [5]int

    // 给数组赋值
    for i := 0; i < len(arr); i++ {
        arr[i] = i * i
    }

    // 打印数组的值
    for _, value := range arr {
        fmt.Println(value)
    }
}

2. Slice (Slice)
   Slice is the implementation of dynamic array in Go language. The length of the slice can be changed dynamically.

Code example:

package main

import "fmt"

func main() {
    // 创建一个空切片
    var slice []int

    // 给切片添加元素
    slice = append(slice, 1)
    slice = append(slice, 2)
    slice = append(slice, 3)

    // 打印切片的容量和长度
    fmt.Println("Capacity:", cap(slice))
    fmt.Println("Length:", len(slice))

    // 打印切片的值
    for _, value := range slice {
        fmt.Println(value)
    }
}

3. Linked List
   Linked list is a linear data structure used to store data. In Go language, pointers can be used to implement linked lists.

Code example:

package main

import "fmt"

type Node struct {
    data int
    next *Node
}

type LinkedList struct {
    head *Node
}

func (list *LinkedList) add(data int) {
    newNode := &Node{data: data}

    if list.head == nil {
        list.head = newNode
    } else {
        current := list.head
        for current.next != nil {
            current = current.next
        }
        current.next = newNode
    }
}

func main() {
    linkedList := &LinkedList{}

    linkedList.add(1)
    linkedList.add(2)
    linkedList.add(3)

    current := linkedList.head
    for current != nil {
        fmt.Println(current.data)
        current = current.next
    }
}

4. Stack (Stack)
   The stack is a last-in-first-out (LIFO) data structure. In Go language, you can use slices to implement stacks.

Code example:

package main

import "fmt"

type Stack struct {
    data []int
}

func (stack *Stack) push(value int) {
    stack.data = append(stack.data, value)
}

func (stack *Stack) pop() int {
    if len(stack.data) == 0 {
        return -1
    }
    value := stack.data[len(stack.data)-1]
    stack.data = stack.data[:len(stack.data)-1]
    return value
}

func main() {
    stack := &Stack{}

    stack.push(1)
    stack.push(2)
    stack.push(3)

    value := stack.pop()
    for value != -1 {
        fmt.Println(value)
        value = stack.pop()
    }
}

5. Queue (Queue)
   Queue is a first-in-first-out (FIFO) data structure. In Go language, you can use slices to implement queues.

Code examples:

package main

import "fmt"

type Queue struct {
    data []int
}

func (queue *Queue) enqueue(value int) {
    queue.data = append(queue.data, value)
}

func (queue *Queue) dequeue() int {
    if len(queue.data) == 0 {
        return -1
    }
    value := queue.data[0]
    queue.data = queue.data[1:]
    return value
}

func main() {
    queue := &Queue{}

    queue.enqueue(1)
    queue.enqueue(2)
    queue.enqueue(3)

    value := queue.dequeue()
    for value != -1 {
        fmt.Println(value)
        value = queue.dequeue()
    }
}

The above code examples cover common data structures in Go language and how to use them. By learning and mastering these data structures, the efficiency and readability of the program can be improved. I hope this article will be helpful for you to learn the data structure of Go language.

The above is the detailed content of Learn to use common data structures and their methods in Go language. For more information, please follow other related articles on the PHP Chinese website!