Recherche sur les structures de données et les applications couramment utilisées en langage Go

Explorez les structures de données et les applications couramment utilisées dans le langage Go

Vue d'ensemble
Le langage Go est un langage de programmation puissant présentant les caractéristiques de simplicité, d'efficacité et de programmation simultanée. Dans la bibliothèque standard de Go, il existe de nombreuses structures de données et algorithmes couramment utilisés, qui fournissent aux développeurs des solutions riches. Cet article se concentrera sur les structures de données couramment utilisées dans le langage Go et fournira des exemples de code correspondants.

1. Array
   Array en langage Go est une séquence de longueur fixe du même type de données. La taille du tableau est déterminée lors de sa création et ne peut pas être modifiée. Voici un exemple de code pour déclarer et initialiser un tableau :

var arr [3]int // 创建一个长度为3的int类型数组
arr[0] = 1     // 第一个元素赋值为1
arr[1] = 2     // 第二个元素赋值为2
arr[2] = 3     // 第三个元素赋值为3

2. Slice
   Une tranche est un tableau dynamique dans le langage Go qui peut automatiquement s'agrandir et se réduire selon les besoins. Contrairement aux tableaux, la longueur d’une tranche peut changer à tout moment. Voici un exemple de code qui déclare et initialise une tranche :

var slice []int                // 创建一个空的int类型切片
slice = append(slice, 1)       // 向切片添加一个元素
slice = append(slice, 2, 3, 4) // 向切片添加多个元素

3. Map (Map)
   Une carte est un tableau associatif en langage Go qui associe des clés et des valeurs. Les clés de la carte sont uniques et chaque clé correspond à une valeur. Ce qui suit est un exemple de code qui déclare et initialise un mappage :

var m map[string]int              // 创建一个空的string类型到int类型的映射
m = make(map[string]int)          // 初始化映射
m["one"] = 1                       // 添加一个键值对
m["two"] = 2                       // 添加另一个键值对

4. Liste chaînée
   Une liste chaînée est une structure de données commune composée d'une série de nœuds, chaque nœud contient un élément de données et un pointeur vers le pointeur suivant. au nœud. Voici un exemple de code pour déclarer et utiliser une liste chaînée :

type Node struct {
    data int
    next *Node
}

func main() {
    var head *Node // 头节点
    var tail *Node // 尾节点

    head = &Node{data: 1}                   // 创建第一个节点
    tail = head                             // 将尾节点指向头节点

    tail.next = &Node{data: 2}              // 创建第二个节点
    tail = tail.next                        // 将尾节点指向第二个节点

    fmt.Println(head.data, head.next.data)  // 输出第一个节点和第二个节点的数据
}

5. Stack
   Stack est une structure de données Last In, First Out (Last In, First Out) qui permet uniquement l'insertion et la suppression à une extrémité de la table. fonctionner. Voici un exemple de code qui utilise des tranches pour implémenter une pile :

type Stack []int

func (s *Stack) Push(data int) {
    *s = append(*s, data)
}

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

func main() {
    var stack Stack
    stack.Push(1)
    stack.Push(2)
    stack.Push(3)
    fmt.Println(stack.Pop())
}

6. Queue
   Queue est une structure de données premier entré, premier sorti (premier entré, premier sorti) qui permet d'effectuer des opérations d'insertion à une extrémité. du tableau. Les opérations de suppression sont effectuées de l’autre côté du tableau. Voici un exemple de code qui utilise des tranches pour implémenter une file d'attente :

type Queue []int

func (q *Queue) Enqueue(data int) {
    *q = append(*q, data)
}

func (q *Queue) Dequeue() int {
    if len(*q) == 0 {
        return 0
    }
    data := (*q)[0]
    *q = (*q)[1:]
    return data
}

func main() {
    var queue Queue
    queue.Enqueue(1)
    queue.Enqueue(2)
    queue.Enqueue(3)
    fmt.Println(queue.Dequeue())
}

Résumé
Cet article présente les structures de données couramment utilisées dans le langage Go et fournit des exemples de code correspondants. Bien que la bibliothèque standard du langage Go ait fourni de nombreuses excellentes structures de données, dans les applications réelles, nous pouvons également avoir besoin de structures de données personnalisées basées sur des besoins spécifiques. En maîtrisant ces structures de données communes, les développeurs peuvent résoudre les problèmes plus efficacement et améliorer la lisibilité et la maintenabilité du code.

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!