Cos'è una coda?
Code sono strutture di dati utilizzate per memorizzare e recuperare elementi in un ordine predeterminato. È una struttura di dati lineare che assomiglia a una pila e aderisce al file FIFO (primo entrato, primo uscito) regola. Può essere paragonato a una lista d'attesa oa una fila in cui la prima persona che arriva viene servita per prima. I componenti esistenti vengono rilasciati dalla parte anteriore del coda e nuovi elementi vengono aggiunti sul retro.
Implementazione di una coda in Golang
L'implementazione dell'a coda in Go è semplice ed efficiente e può essere implementato utilizzando i seguenti quattro metodi.
1: Fette
In Vai, a fetta è un array dinamico che può cambiare dimensione. Per implementare un coda usare un fetta , possiamo aggiungere elementi sul retro del file fetta utilizzando la funzione di accodamento incorporata e rimuovi gli elementi dalla parte anteriore del file fetta usando l'affettatura.
Questo approccio è facile da costruire e offre buone prestazioni per le operazioni di aggiunta e suddivisione grazie alle sezioni integrate di Go. Tuttavia, il metodo di slicing, che include la copia di elementi in un nuovo array sottostante, può diventare inefficiente se il metodo coda si espande e richiede ripetute operazioni di rimozione dalla coda.
Il codice seguente definisce il coda implementazione utilizzando una sezione in Go.
pacchetto principale
importare 'fmt'
funzione principale ( ) {
coda := Fare ( [ ] interfaccia { } , 0 )
coda = aggiungere ( coda , 'inglese' )
coda = aggiungere ( coda , 'urdu' )
coda = aggiungere ( coda , 'matematica' )
Se soltanto ( coda ) > 0 {
articolo := coda [ 0 ]
coda = coda [ 1 : ]
fmt. Stampaln ( articolo )
}
Se soltanto ( coda ) == 0 {
fmt. Stampaln ( 'La coda è vuota' )
} altro {
fmt. Stampaln ( coda )
}
}
Il codice Go precedente usa una slice per costruire un semplice coda struttura dati. IL aggiungere() La funzione viene utilizzata per accodare gli elementi nel file coda slice e un'operazione slice che rimuove l'elemento iniziale viene utilizzata per rimuoverli dalla coda. Con fmt.Println() , viene stampato l'elemento rimosso dalla coda. Il codice utilizza quindi il soltanto() funzione per determinare se la coda è vuota, e se lo è, scrive ' Coda è vuoto” utilizzando la funzione fmt.Println().
Produzione
2: Elenchi collegati
I nodi che portano un valore e un puntatore al nodo seguente nell'elenco costituiscono un elenco collegato. Con due puntatori, uno rivolto verso la parte anteriore (testa) dell'elenco e l'altro verso la parte posteriore (coda), possiamo implementare un coda utilizzando un elenco collegato. La rimozione di un elemento dalla coda (rimozione dall'accodamento) comporta la rimozione del nodo all'inizio dell'elenco mentre l'aggiunta di un elemento alla coda (accodamento) comporta l'aggiunta di un nuovo nodo in fondo all'elenco.
Questo metodo consente operazioni di accodamento e rimozione dalla coda efficienti perché è necessario modificare solo i puntatori di testa e coda, al contrario della soluzione basata su sezioni in cui gli elementi dovrebbero essere copiati.
Utilizzare un elenco collegato per implementare a coda utilizzando il codice fornito di seguito:
pacchetto principaleimportare 'fmt'
digitare Nodo struct {
interfaccia di valore { }
Prossimo * Nodo
}
digitare Coda struct {
Testa * Nodo
coda * Nodo
}
funzione principale ( ) {
coda := & Coda { Testa : zero , coda : zero }
newNode := & Nodo { valore : 'inglese' , Prossimo : zero }
coda. coda = newNode
coda. Testa = newNode
newNode = & Nodo { valore : 'urdu' , Prossimo : zero }
coda. coda . Prossimo = newNode
coda. coda = newNode
newNode = & Nodo { valore : 'matematica' , Prossimo : zero }
coda. coda . Prossimo = newNode
coda. coda = newNode
Se coda. Testa != zero {
articolo := coda. Testa . valore
coda. Testa = coda. Testa . Prossimo
fmt. Stampaln ( articolo )
}
Se coda. Testa == zero {
fmt. Stampaln ( 'La coda è vuota' )
}
}
La struttura Node rappresenta ogni elemento nella coda e contiene due campi: un campo valore per memorizzare il valore dell'elemento e il campo next per puntare all'elemento successivo nella coda. Lo struct Queue utilizza le proprietà head e tail per tenere traccia rispettivamente della parte anteriore e posteriore della coda. IL di coda il primo elemento è indicato dalla proprietà head, mentre il suo ultimo elemento è indicato dalla proprietà tail.
I parametri head e tail sono inizialmente impostati su zero quando un nuovo coda è stabilito nella funzione main(). I puntatori head e tail vengono aggiornati per aggiungere tre nodi al file coda con i valori “inglese”, “urdu”, E 'matematica'. IL 'inglese' l'articolo è allora 'rimosso dalla coda' (rimosso) dalla parte anteriore del coda visualizzandone il valore e facendo avanzare il puntatore head al nodo successivo nel file coda . Dopo la rimozione dalla coda, se la testa diventa nulla, significa che la coda è vuota e il messaggio ' Coda è vuoto” viene stampato.
Produzione
3: Strutture
In Go, puoi creare una struttura dati personalizzata chiamata a struct rappresentare un coda . Questo struct può avere campi per memorizzare il file coda elementi e metodi per aggiungere e rimuovere elementi, verificare se la coda è vuota e ottenere la dimensione corrente della coda.
Questo modo di creare un coda in Go offre un'implementazione conveniente e incapsulata con metodi di facile utilizzo che possono essere espansi e personalizzati con più funzionalità. È un approccio flessibile che consente di apportare modifiche all'implementazione o di aggiungere nuove funzionalità quando necessario.
Creazione di un'abitudine struct con i metodi comporta la scrittura di codice aggiuntivo rispetto agli altri due modi, il che può aumentare la complessità. Tuttavia, fornisce anche maggiore flessibilità e controllo sull'implementazione del coda .
L'esempio seguente mostra la creazione di una struttura dati per rappresentare a coda in Vai.
pacchetto principaleimportare 'fmt'
digitare Coda struct {
elementi [ ] interfaccia { }
}
funz ( Q * Coda ) Accodare ( interfaccia elemento { } ) {
Q. elementi = aggiungere ( Q. elementi , articolo )
}
funz ( Q * Coda ) Rimuovi dalla coda ( ) interfaccia { } {
Se soltanto ( Q. elementi ) == 0 {
ritorno zero
}
articolo := Q. elementi [ 0 ]
Q. elementi = Q. elementi [ 1 : ]
ritorno articolo
}
funz ( Q * Coda ) È vuoto ( ) bool {
ritorno soltanto ( Q. elementi ) == 0
}
funz ( Q * Coda ) Misurare ( ) int {
ritorno soltanto ( Q. elementi )
}
funzione principale ( ) {
coda := & Coda { elementi : Fare ( [ ] interfaccia { } , 0 ) }
coda. Accodare ( 'inglese' )
coda. Accodare ( 'urdu' )
coda. Accodare ( 'matematica' )
articolo := coda. Rimuovi dalla coda ( )
fmt. Stampaln ( articolo )
Se coda. È vuoto ( ) {
fmt. Stampaln ( 'La coda è vuota' )
}
misurare := coda. Misurare ( )
fmt. Stampaln ( 'Dimensione della coda:' , misurare )
}
Nel codice precedente, un elemento viene aggiunto alla sezione dell'elemento tramite il file Accodare() metodo, che lo sposta alla fine del coda . Seguendo il Primo a entrare, primo a uscire (FIFO) principio, il Rimuovi dalla coda() metodo prende un oggetto dalla parte anteriore del coda e lo restituisce. La lunghezza della sezione dell'elemento viene controllata come parte del È vuoto() controllo del metodo per vedere se il coda è vuoto. Restituendo la lunghezza della sezione degli elementi, il file Misurare() metodo restituisce la corrente di coda misurare.
La funzione main() utilizza il Struttura della coda per creare un nuovo coda , aggiungi elementi ad esso, rimuovi elementi da esso, determina se il file coda è vuoto e calcolarne le dimensioni.
Produzione
4: Canali
In Go, il tipo di canale integrato può essere utilizzato per implementare a coda struttura dati. Il canale può essere creato con una dimensione del buffer per limitare il numero di elementi che possono essere accodati in un dato momento. Per aggiungere un elemento al coda , può essere inviato al canale utilizzando il file <- operatore, mentre per rimuovere un elemento dalla coda è possibile riceverlo dal canale utilizzando lo stesso operatore.
Questo approccio può essere molto utile in situazioni in cui l'accesso simultaneo a coda è necessario, poiché i canali sono intrinsecamente sicuri per l'uso simultaneo.
È fondamentale ricordare che i canali Go sono digitati. Ciò significa che puoi inviare solo valori di un tipo specifico attraverso un canale e puoi ricevere solo valori dello stesso tipo dal canale.
Questa è un'illustrazione di come utilizzare un canale per costruire a coda struttura dei dati in Go.
pacchetto principaleimportare (
'fmt'
'tempo'
)
digitare Coda struct {
elementi chaninterfaccia { }
}
funcNewQueue ( ) * Coda {
Q := & Coda {
elementi : Fare ( interfaccia canale { } ) ,
}
vai q. processItems ( )
ritorno Q
}
funz ( Q * Coda ) processItems ( ) {
per articolo := intervallo q. elementi {
Se articolo == 'inglese' {
fmt. Stampaln ( 'Rimosso dalla coda:' , articolo )
}
}
}
funz ( Q * Coda ) Accodare ( interfaccia elemento { } ) {
Q. elementi <- articolo
}
funcmain ( ) {
coda := Nuova coda ( )
coda. Accodare ( 'inglese' )
coda. Accodare ( 'urdu' )
coda. Accodare ( 'matematica' )
tempo . Sonno ( 2 * tempo . Secondo )
}
Il codice precedente crea un file Struttura della coda con un unico campo elementi che è un canale di interfaccia{} tipo. IL Nuova coda() La funzione crea una nuova istanza di Coda e inizializza il suo 'elementi' campo con un nuovo canale senza buffer. Avvia anche una nuova goroutine per elaborare gli elementi aggiunti alla coda utilizzando il file processItems() funzione. IL processItems() funzione controlla se l'articolo ricevuto è uguale a 'inglese' e stampa un messaggio alla console solo per quell'elemento. IL Accodare() La funzione viene utilizzata per aggiungere nuovi elementi alla coda.
Produzione
Conclusione
La coda è una struttura dati essenziale in Go utilizzata per archiviare e recuperare elementi in un ordine specifico. L'implementazione dell'a coda in Go è thread-safe, il che li rende la scelta ideale per implementare la concorrenza nei programmi. Può essere implementato utilizzando sezioni, elenchi collegati, strutture e canali. I dettagli completi sono già forniti nelle linee guida sopra riportate.