Go Language Analyse de la structure des données : maîtrisez les secrets des files d'attente et des piles

La file d'attente suit le principe FIFO et fournit les opérations Enqueue, Dequeue et Peek ; la pile suit le principe LIFO et fournit les opérations Push, Pop et Peek. Les files d'attente sont utilisées pour les files d'attente de tâches et les piles sont utilisées pour les appels de fonction, la récursivité et la correspondance entre crochets.

Analyse de la structure des données du langage Go : maîtrisez les secrets des files d'attente et des piles

Avant-propos

Les piles et les files d'attente sont des structures de données cruciales en informatique et jouent un rôle indispensable dans diverses applications. Dans le langage Go, ils fournissent des outils puissants pour gérer les données et résoudre des problèmes complexes. Cet article se penchera sur les piles et les files d'attente dans le langage Go, en fournissant des explications claires, des exemples de code et des cas pratiques pour vous donner une compréhension approfondie de ces structures de données.

Queue

Queue est une structure de données linéaire qui suit le principe du premier entré, premier sorti (FIFO). Ses opérations incluent :

• Enqueue() : Ajouter un élément à la fin de la file d'attente Enqueue()：将一个元素添加到队列的末尾
• Dequeue()：从队列的开头移除一个元素
• Peek()：读取队列中第一个而不删除元素

代码示例：

type Queue []int

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

func (q *Queue) Dequeue() int {
    if q.IsEmpty() {
        panic("queue is empty")
    }
    x := (*q)[0]
    *q = (*q)[1:]
    return x
}

func (q *Queue) Peek() int {
    if q.IsEmpty() {
        panic("queue is empty")
    }
    return (*q)[0]
}

func (q *Queue) IsEmpty() bool {
    return len(*q) == 0
}

实战案例：

• 任务队列：将任务添加到队列中，然后按照先到先服务的顺序处理它们。

栈

栈是一种遵循后入先出 (LIFO) 原则的线性数据结构。它的操作包括：

• Push()：将一个元素压入栈的顶部
• Pop()：从栈的顶部弹出并移除一个元素
• Peek()
Dequeue() : Supprimer un élément du début de la file d'attente

Peek() : Lire le premier élément de la file d'attente sans le supprimer

Exemple de code :

type Stack []int

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

func (s *Stack) Pop() int {
    if s.IsEmpty() {
        panic("stack is empty")
    }
    x := (*s)[len(*s)-1]
    *s = (*s)[:len(*s)-1]
    return x
}

func (s *Stack) Peek() int {
    if s.IsEmpty() {
        panic("stack is empty")
    }
    return (*s)[len(*s)-1]
}

func (s *Stack) IsEmpty() bool {
    return len(*s) == 0
}

Cas pratique :
• File d'attente de tâches : Ajouter la tâche à la file d'attente et traitez-les dans l'ordre du premier arrivé, premier servi.
• Stack

La pile est une structure de données linéaire qui suit le principe du dernier entré, premier sorti (LIFO). Ses opérations incluent : 🎜🎜🎜Push() : pousser un élément vers le haut de la pile 🎜🎜Pop() : pop et supprimer un élément du haut de la pile stack + Variables locales et contexte au moment de l’appel de la fonction. 🎜🎜🎜Récursion : 🎜La pile est utilisée pour stocker l'adresse de retour des appels de fonction récursifs. 🎜🎜🎜Correspondance des supports : 🎜Utilisez la pile pour vérifier si les supports correspondent. 🎜🎜

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!