Du débutant au compétent : implémentation de code de structures de données couramment utilisées en langage Go

Titre : Du débutant à la maîtrise : Implémentation du code de structures de données couramment utilisées dans le langage Go

Les structures de données jouent un rôle essentiel dans la programmation et sont la base de la programmation. Dans le langage Go, il existe de nombreuses structures de données couramment utilisées, et maîtriser la mise en œuvre de ces structures de données est crucial pour devenir un bon programmeur. Cet article présentera les structures de données couramment utilisées dans le langage Go et donnera des exemples de code correspondants pour aider les lecteurs à démarrer et à maîtriser ces structures de données.

1.Array

Array est une structure de données de base, qui est un ensemble d'éléments du même type. En langage Go, la longueur des tableaux est fixe. Ce qui suit est un exemple de déclaration et d'utilisation d'un tableau d'entiers simple :

package main

import "fmt"

func main() {
    var arr [5]int
    arr[0] = 1
    arr[1] = 2
    arr[2] = 3
    arr[3] = 4
    arr[4] = 5

    fmt.Println(arr) // 打印数组

    // 遍历数组
    for i := 0; i < len(arr); i++ {
        fmt.Printf("%d ", arr[i])
    }
}

2. Slice

Une tranche est une structure de données basée sur un tableau qui peut augmenter ou diminuer dynamiquement la longueur. Voici un exemple de déclaration et d'utilisation d'une tranche entière simple :

package main

import "fmt"

func main() {
    var slice []int
    slice = append(slice, 1)
    slice = append(slice, 2, 3, 4, 5)

    fmt.Println(slice) // 打印切片

    // 遍历切片
    for _, value := range slice {
        fmt.Printf("%d ", value)
    }
}

3. Queue (Queue)

Queue est une structure de données premier entré, premier sorti (FIFO). Ce qui suit est un exemple d'implémentation d'une file d'attente d'entiers simple :

package main

import "fmt"

type Queue struct {
    items []int
}

func (q *Queue) Enqueue(item int) {
    q.items = append(q.items, item)
}

func (q *Queue) Dequeue() int {
    if len(q.items) == 0 {
        return -1
    }
    item := q.items[0]
    q.items = q.items[1:]
    return item
}

func main() {
    queue := Queue{}

    queue.Enqueue(1)
    queue.Enqueue(2)
    queue.Enqueue(3)

    fmt.Println(queue.Dequeue()) // 输出1
    fmt.Println(queue.Dequeue()) // 输出2
}

4 Stack

La pile est une structure de données dernier entré, premier sorti (LIFO). Ce qui suit est un exemple simple d'implémentation d'une pile d'entiers :

package main

import "fmt"

type Stack struct {
    items []int
}

func (s *Stack) Push(item int) {
    s.items = append(s.items, item)
}

func (s *Stack) Pop() int {
    if len(s.items) == 0 {
        return -1
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

func main() {
    stack := Stack{}

    stack.Push(1)
    stack.Push(2)
    stack.Push(3)

    fmt.Println(stack.Pop()) // 输出3
    fmt.Println(stack.Pop()) // 输出2
}

En étudiant l'exemple de code ci-dessus, les lecteurs peuvent progressivement maîtriser l'implémentation des structures de données couramment utilisées dans le langage Go, de l'entrée à la maîtrise, et améliorer leurs compétences en programmation. J'espère que cet article vous aidera !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!