Quelle est la file d'attente à Golang ?

Quelle Est La File D Attente A Golang



Go est un langage de programmation populaire apprécié pour son efficacité, sa facilité d'utilisation et son adaptabilité. Avec un riche ensemble d'outils et de bibliothèques, Go fournit aux développeurs les ressources nécessaires pour créer des applications logicielles puissantes et efficaces. Bien que Go n'ait pas queues dans sa bibliothèque standard en tant que structure de données, ils peuvent être implémentés à l'aide de diverses méthodes. Nous parlerons de la notion de queues et comment les mettre en œuvre dans ce tutoriel.

Qu'est-ce qu'une file d'attente ?

Queues sont des structures de données utilisées pour stocker et récupérer des éléments dans un ordre prédéterminé. Il s'agit d'une structure de données linéaire qui ressemble à une pile et adhère au FIFO (premier entré, premier sorti) règle. Cela peut être comparé à une liste d'attente ou à une file d'attente où la première personne qui arrive est servie en premier. Les composants existants sont supprimés de l'avant du file d'attente , et de nouveaux éléments sont ajoutés à l'arrière.

Implémentation d'une file d'attente dans Golang

La mise en place d'un file d'attente in Go est simple et efficace et peut être mis en œuvre en utilisant les quatre méthodes suivantes.







1 : Tranches

Au Go, un tranche est un tableau dynamique dont la taille peut changer. Pour mettre en place un file d'attente utilisant un tranche , nous pouvons ajouter des éléments à l'arrière du tranche en utilisant la fonction d'ajout intégrée et supprimer des éléments de l'avant de la tranche en utilisant le tranchage.



Cette approche est facile à construire et offre de bonnes performances pour les opérations d'ajout et de découpage grâce aux tranches intégrées de Go. Cependant, la méthode de découpage, qui inclut la copie d'éléments dans un nouveau tableau sous-jacent, peut devenir inefficace si le file d'attente s'agrandit et nécessite des opérations répétées de retrait de la file d'attente.



Le code suivant définit le file d'attente implémentation à l'aide d'une tranche dans Go.





paquet principal

importer 'fmt'

fonction principale ( ) {

file d'attente := faire ( [ ] interface { } , 0 )

file d'attente = ajouter ( file d'attente , 'Anglais' )

file d'attente = ajouter ( file d'attente , 'ourdou' )

file d'attente = ajouter ( file d'attente , 'mathématiques' )

si seul ( file d'attente ) > 0 {

article := file d'attente [ 0 ]

file d'attente = file d'attente [ 1 : ]

fmt. Imprimerln ( article )

}

si seul ( file d'attente ) == 0 {

fmt. Imprimerln ( 'La file d'attente est vide' )

} autre {

fmt. Imprimerln ( file d'attente )

}

}

Le code Go ci-dessus utilise une tranche pour construire un simple file d'attente Structure de données. Le ajouter() La fonction est utilisée pour mettre des éléments en file d'attente dans la file d'attente slice, et une opération slice qui supprime l'élément initial est utilisée pour les retirer de la file d'attente. Avec fmt.Println() , l'élément retiré de la file d'attente est imprimé. Le code utilise alors le seul() fonction pour déterminer si la file d'attente est vide, et si c'est le cas, elle écrit ' File d'attente est vide » en utilisant la fonction fmt.Println().

Sortir



2 : Listes liées

Les nœuds qui portent une valeur et un pointeur vers le nœud suivant dans la liste constituent une liste chaînée. Avec deux pointeurs, l'un pointant vers l'avant (tête) de la liste et l'autre pointant vers l'arrière (queue), nous pouvons implémenter un file d'attente à l'aide d'une liste chaînée. La suppression d'un élément de la file d'attente (mise en file d'attente) implique la suppression du nœud au début de la liste, tandis que l'ajout d'un élément à la file d'attente (mise en file d'attente) implique l'ajout d'un nouveau nœud à l'arrière de la liste.

Cette méthode permet des opérations de mise en file d'attente et de retrait efficaces car seuls les pointeurs de tête et de queue doivent être modifiés, contrairement à la solution basée sur les tranches où les éléments devraient être copiés.

Utiliser une liste chaînée pour implémenter un file d'attente en utilisant le code fourni ci-dessous :

paquet principal

importer 'fmt'

type Noeud structure {

interface de valeur { }

suivant * Nœud

}

tapez la file d'attente structure {

diriger * Nœud

queue * Nœud

}

fonction principale ( ) {

file d'attente := & File d'attente { diriger : néant , queue : néant }

nouveauNoeud := & Nœud { valeur : 'Anglais' , suivant : néant }

file d'attente. queue = nouveauNoeud

file d'attente. diriger = nouveauNoeud

nouveauNoeud = & Nœud { valeur : 'ourdou' , suivant : néant }

file d'attente. queue . suivant = nouveauNoeud

file d'attente. queue = nouveauNoeud

nouveauNoeud = & Nœud { valeur : 'mathématiques' , suivant : néant }

file d'attente. queue . suivant = nouveauNoeud

file d'attente. queue = nouveauNoeud

si file d'attente. diriger != néant {

article := file d'attente. diriger . valeur

file d'attente. diriger = file d'attente. diriger . suivant

fmt. Imprimerln ( article )

}

si file d'attente. diriger == néant {

fmt. Imprimerln ( 'La file d'attente est vide' )

}

}

La structure Node représente chaque élément de la file d'attente et contient deux champs : un champ de valeur pour stocker la valeur de l'élément et le champ suivant pour pointer vers l'élément suivant de la file d'attente. La structure Queue utilise les propriétés head et tail pour suivre respectivement l'avant et l'arrière de la file d'attente. Le queue’s premier élément est indiqué par la propriété head, tandis que son dernier élément est indiqué par la propriété tail.

Les paramètres de tête et de queue sont initialement définis sur néant quand un nouveau file d'attente est établie dans la fonction main(). Les pointeurs de tête et de queue sont mis à jour pour ajouter trois nœuds au file d'attente avec les valeurs 'anglais', 'ourdou', et 'mathématiques'. Le 'Anglais' l'article est alors 'en file d'attente' (supprimé) de l'avant du file d'attente en affichant sa valeur et en avançant le pointeur principal vers le nœud suivant dans le file d'attente . Après le retrait de la file d'attente, si la tête devient nulle, cela signifie que la file d'attente est vide et le message ' File d'attente est vide » est imprimé.

Sortir

3 : Ouvrages

Dans Go, vous pouvez créer une structure de données personnalisée appelée structure représenter un file d'attente . Ce structure peut avoir des champs pour stocker les file d'attente éléments et méthodes pour ajouter et supprimer des éléments, vérifier si la file d'attente est vide et obtenir la taille actuelle de la file d'attente.

Cette façon de créer un file d'attente in Go offre une implémentation pratique et encapsulée avec des méthodes faciles à utiliser qui peuvent être étendues et personnalisées avec plus de fonctionnalités. Il s'agit d'une approche flexible qui permet d'apporter des modifications à la mise en œuvre ou d'ajouter de nouvelles fonctionnalités chaque fois que nécessaire.

Créer une coutume structure avec les méthodes implique l'écriture de code supplémentaire par rapport aux deux autres méthodes, ce qui peut augmenter la complexité. Cependant, il offre également plus de flexibilité et de contrôle sur la mise en œuvre du file d'attente .

L'exemple suivant illustre la création d'une structure de données pour représenter un file d'attente en Go.

paquet principal

importer 'fmt'

tapez la file d'attente structure {
articles [ ] interface { }
}

fonction ( q * File d'attente ) Mettre en file d'attente ( interface article { } ) {
Q. articles = ajouter ( Q. articles , article )
}

fonction ( q * File d'attente ) Dequeue ( ) interface { } {
si seul ( Q. articles ) == 0 {
retour néant
}
article := Q. articles [ 0 ]
Q. articles = Q. articles [ 1 : ]
retour article
}

fonction ( q * File d'attente ) Est vide ( ) bourdonner {
retour seul ( Q. articles ) == 0
}

fonction ( q * File d'attente ) Taille ( ) entier {
retour seul ( Q. articles )
}


fonction principale ( ) {

file d'attente := & File d'attente { articles : faire ( [ ] interface { } , 0 ) }

file d'attente. Mettre en file d'attente ( 'Anglais' )
file d'attente. Mettre en file d'attente ( 'ourdou' )
file d'attente. Mettre en file d'attente ( 'mathématiques' )

article := file d'attente. Dequeue ( )
fmt. Imprimerln ( article )
si file d'attente. Est vide ( ) {
fmt. Imprimerln ( 'La file d'attente est vide' )
}

taille := file d'attente. Taille ( )
fmt. Imprimerln ( 'Taille de la file d'attente :' , taille )
}

Dans le code ci-dessus, un élément est ajouté à la tranche de l'élément via le Mettre en file d'attente() méthode, qui le déplace à la fin de la file d'attente . Suivant le Premier entré, premier sorti (FIFO) principe, le Dequeue() La méthode prend un élément sur le devant de la file d'attente et le retourne. La longueur de la tranche de l'élément est vérifiée dans le cadre de la Est vide() vérification de la méthode pour voir si file d'attente est vide. En renvoyant la longueur de la tranche d'éléments, le Taille() méthode renvoie le courant queue’s taille.

La fonction main() utilise le Structure de la file d'attente pour créer un nouveau file d'attente , y ajouter des éléments, en supprimer des éléments, déterminer si le file d'attente est vide et calculez sa taille.

Sortir

4 : Canaux

Dans Go, le type de canal intégré peut être utilisé pour implémenter un file d'attente Structure de données. Le canal peut être créé avec une taille de mémoire tampon pour limiter le nombre d'éléments pouvant être mis en file d'attente à un moment donné. Pour ajouter un élément au file d'attente , il peut être envoyé au canal en utilisant le <- tandis que pour supprimer un élément de la file d'attente, il peut être reçu du canal en utilisant le même opérateur.

Cette approche peut être très utile dans les situations où l'accès simultané au file d'attente est nécessaire, car les canaux sont intrinsèquement sûrs pour une utilisation simultanée.

Il est crucial de se rappeler que les canaux Go sont typés. Cela signifie que vous ne pouvez envoyer que des valeurs d'un type spécifique via un canal et que vous ne pouvez recevoir que des valeurs de ce même type à partir du canal.

Ceci est une illustration de la façon d'utiliser un canal pour construire un file d'attente structure de données en Go.

paquet principal

importer (
'fmt'
'temps'
)

tapez la file d'attente structure {
interface de changement d'articles { }
}

funcNewQueue ( ) * File d'attente {


q := & File d'attente {

articles : faire ( interface utilisateur { } ) ,
}
allez Q. éléments de processus ( )
retour q
}

fonction ( q * File d'attente ) éléments de processus ( ) {
pour article := gamme Q. articles {
si article == 'Anglais' {
fmt. Imprimerln ( 'Retiré de la file d'attente :' , article )
}
}
}


fonction ( q * File d'attente ) Mettre en file d'attente ( interface article { } ) {

Q. articles <- article

}

fonction principale ( ) {
file d'attente := Nouvelle file d'attente ( )

file d'attente. Mettre en file d'attente ( 'Anglais' )
file d'attente. Mettre en file d'attente ( 'ourdou' )
file d'attente. Mettre en file d'attente ( 'mathématiques' )

temps . Dormir ( 2 * temps . Deuxième )
}

Le code ci-dessus crée un Structure de la file d'attente avec un seul champ articles qui est un canal de interface{} taper. Le NouvelleQueue() La fonction crée une nouvelle instance de File d'attente et initialise son 'articles' champ avec un nouveau canal sans tampon. Il démarre également une nouvelle goroutine pour traiter les éléments ajoutés à la file d'attente à l'aide de la traiter les éléments () fonction. Le traiter les éléments () la fonction vérifie si l'élément reçu est égal à 'Anglais' et affiche un message sur la console uniquement pour cet élément. Le Mettre en file d'attente() La fonction est utilisée pour ajouter de nouveaux éléments à la file d'attente.

Sortir

Conclusion

La file d'attente est une structure de données essentielle dans Go utilisée pour stocker et récupérer des éléments dans un ordre spécifique. La mise en place d'un file d'attente in Go est thread-safe, ce qui en fait un choix idéal pour implémenter la concurrence dans les programmes. Il peut être implémenté à l'aide de tranches, de listes chaînées, de structures et de canaux. Les détails complets sont déjà fournis dans les directives ci-dessus.