Recherche sur la structure des données du langage Go : application de la file d'attente et de la pile

Dans le langage Go, la file d'attente suit le principe du premier entré, premier sorti (FIFO) et est implémentée à l'aide du package list de la bibliothèque standard. Elle est souvent utilisée dans les systèmes de messagerie ; -out (LIFO) et est souvent utilisé pour le suivi des appels de fonction et la correspondance entre crochets. Implémenté à l'aide de tranches.

Exposé sur la structure des données du langage Go : Application de la file d'attente et de la pile

Queue

La file d'attente est une structure de données qui adhère au principe du premier entré, premier sorti (FIFO). Cela signifie que les premiers éléments entrés dans la file d'attente seront supprimés en premier. Les files d'attente sont très utiles dans les scénarios suivants :

• Systèmes de livraison de messages, tels que les files d'attente de messages
• Tampons, tels que les files d'attente de requêtes réseau

Implémentation de files d'attente en langage Go

L'implémentation la plus courante des files d'attente en Go langage Il utilise le container/listpackage de bibliothèque standard :

import (
    "container/list"
)

// 定义队列类型
type Queue struct {
    items *list.List
}

// 创建队列
func NewQueue() *Queue {
    return &Queue{
        items: list.New(),
    }
}

// 进队
func (q *Queue) Enqueue(item interface{}) {
    q.items.PushBack(item)
}

// 出队
func (q *Queue) Dequeue() interface{} {
    if q.IsEmpty() {
        return nil
    }
    front := q.items.Front()
    q.items.Remove(front)
    return front.Value
}

// 判断队列是否为空
func (q *Queue) IsEmpty() bool {
    return q.items.Len() == 0
}

Cas pratique : Message Queue

La file d'attente de messages est un scénario d'application typique de file d'attente. Nous pouvons utiliser la file d'attente du langage Go pour implémenter une file d'attente de messages :

func main() {
    // 创建消息队列
    queue := NewQueue()

    // 向队列发送消息
    queue.Enqueue("消息 1")
    queue.Enqueue("消息 2")

    // 接收消息
    for {
        msg := queue.Dequeue()
        if msg == nil {
            break
        }
        fmt.Println(msg)
    }
}

Stack

La pile est une structure de données qui adhère au principe du dernier entré, premier sorti (LIFO). Cela signifie que le dernier élément ajouté à la pile sera supprimé en premier. La pile est très utile dans les scénarios suivants :

• Traçage des appels de fonction
• Bracket matching

Implémentation de la pile en langage Go

L'implémentation la plus simple de la pile en langage Go est d'utiliser des slices :

// 定义栈类型
type Stack []interface{}

// 进栈
func (s *Stack) Push(item interface{}) {
    *s = append(*s, item)
}

// 出栈
func (s *Stack) Pop() interface{} {
    if s.Empty() {
        return nil
    }
    top := (*s)[len(*s)-1]
    *s = (*s)[:len(*s)-1]
    return top
}

// 判断栈是否为空
func (s *Stack) Empty() bool {
    return len(*s) == 0
}

Cas de combat pratique : correspondance des supports

Stack est un excellent outil pour vérifier la correspondance des supports :

func isBalanced(expr string) bool {
    stack := Stack{}
    for _, char := range expr {
        if char == '(' || char == '[' || char == '{' {
            stack.Push(char)
        } else if char == ')' || char == ']' || char == '}' {
            if stack.Empty() {
                return false
            }
            top := stack.Pop()
            if (char == ')' && top != '(') || (char == ']' && top != '[') || (char == '}' && top != '{') {
                return false
            }
        }
    }
    return stack.Empty()
}

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!