Ce este o coadă?
Cozi sunt structuri de date care sunt folosite pentru a stoca și a prelua elemente într-o ordine predeterminată. Este o structură de date liniară care seamănă cu o stivă și aderă la FIFO (primul intrat, primul ieșit) regulă. Poate fi comparat cu o listă de așteptare sau cu o linie în care prima persoană care sosește este deservită prima. Componentele existente sunt aruncate din față coadă , iar noi elemente sunt adăugate în spate.
Implementarea unei cozi în Golang
Implementarea a coadă in Go este simplu și eficient și poate fi implementat folosind următoarele patru metode.
1: felii
În Go, a felie este o matrice dinamică care se poate schimba în dimensiune. Pentru a implementa a coadă folosind un felie , putem adăuga elemente în spatele felie folosind funcția de adăugare încorporată și eliminați elementele din față felie folosind felierea.
Această abordare este ușor de construit și oferă performanțe bune pentru operațiunile de adăugare și tăiere datorită feliilor încorporate ale Go. Cu toate acestea, metoda de tăiere, care include copierea elementelor într-o nouă matrice de bază poate deveni ineficientă dacă coadă se extinde și necesită operații repetate de scoatere din coadă.
Următorul cod definește coadă implementare folosind o felie în Go.
pachet principal
import 'fmt'
func principal ( ) {
coadă := face ( [ ] interfata { } , 0 )
coadă = adăuga ( coadă , 'Engleză' )
coadă = adăuga ( coadă , 'urdu' )
coadă = adăuga ( coadă , 'matematica' )
dacă numai ( coadă ) > 0 {
articol := coadă [ 0 ]
coadă = coadă [ 1 : ]
fmt. Println ( articol )
}
dacă numai ( coadă ) == 0 {
fmt. Println ( „Coada este goală” )
} altfel {
fmt. Println ( coadă )
}
}
Codul Go de mai sus folosește o felie pentru a construi un simplu coadă structură de date. The adăuga() funcția este utilizată pentru a pune în coadă elemente în coadă slice, iar o operație de slice care elimină elementul inițial este utilizată pentru a le scoate din coadă. Cu fmt.Println() , elementul scos din coadă este imprimat. Codul folosește apoi numai() funcție pentru a determina dacă coada este goală și, dacă este, scrie „ Coadă este gol” folosind funcția fmt.Println().
Ieșire
2: Liste legate
Nodurile care poartă o valoare și un pointer către următorul nod din listă formează o listă legată. Cu două indicatori, unul îndreptat spre partea din față (capul) listei și celălalt spre spate (coada), putem implementa un coadă folosind o listă legată. Scoaterea unui articol din coadă (decodare) implică eliminarea nodului din partea din față a listei, în timp ce adăugarea unui articol la coadă (acodare) implică adăugarea unui nou nod în spatele listei.
Această metodă permite operațiuni eficiente de așezare și scoatere din coadă, deoarece doar pointerii cap și coadă trebuie modificați, spre deosebire de soluția bazată pe secțiuni în care elementele ar trebui copiate.
Utilizați o listă legată pentru a implementa a coadă folosind codul furnizat mai jos:
pachet principalimport 'fmt'
tip Node struct {
interfață de valoare { }
Următorul * Nodul
}
tip Coadă struct {
cap * Nodul
coadă * Nodul
}
func principal ( ) {
coadă := & Coadă { cap : zero , coadă : zero }
newNode := & Nodul { valoare : 'Engleză' , Următorul : zero }
coadă. coadă = newNode
coadă. cap = newNode
newNode = & Nodul { valoare : 'urdu' , Următorul : zero }
coadă. coadă . Următorul = newNode
coadă. coadă = newNode
newNode = & Nodul { valoare : 'matematica' , Următorul : zero }
coadă. coadă . Următorul = newNode
coadă. coadă = newNode
dacă coadă. cap != zero {
articol := coadă. cap . valoare
coadă. cap = coadă. cap . Următorul
fmt. Println ( articol )
}
dacă coadă. cap == zero {
fmt. Println ( „Coada este goală” )
}
}
Structura Nod reprezintă fiecare articol din coadă și conține două câmpuri: un câmp de valoare pentru stocarea valorii articolului și următorul câmp pentru a indica următorul articol din coadă. Structura Queue folosește proprietățile cap și coadă pentru a ține evidența față și, respectiv, spate a cozii. The coada lui primul articol este indicat de proprietatea head, în timp ce ultimul său element este indicat de proprietatea coadă.
Parametrii cap și coadă sunt setați inițial la zero când un nou coadă este stabilit în funcția main(). Indicatorii cap și coadă sunt actualizați pentru a adăuga trei noduri la coadă cu valorile „engleză”, „urdu”, și 'matematica'. The 'Engleză' elementul este atunci „din coadă” (înlăturat) din partea din față a coadă prin afișarea valorii acesteia și avansarea indicatorului de cap către următorul nod din coadă . După scoatere din coadă, dacă capul devine nul, înseamnă că coada este goală, iar mesajul „ Coadă este gol” este tipărit.
Ieșire
3: Structuri
În Go, puteți crea o structură de date personalizată numită a struct a reprezenta o coadă . Acest struct poate avea câmpuri pentru a stoca coadă elemente și metode pentru a adăuga și elimina articole, verificați dacă coada este goală și obțineți dimensiunea curentă a cozii.
Acest mod de a crea un coadă in Go oferă o implementare convenabilă și încapsulată cu metode ușor de utilizat, care pot fi extinse și personalizate cu mai multe funcții. Este o abordare flexibilă care permite modificarea implementării sau adăugarea de noi capabilități ori de câte ori este necesar.
Crearea unui personalizat struct cu metode implică scrierea de cod suplimentar în comparație cu celelalte două moduri, ceea ce poate crește complexitatea. Cu toate acestea, oferă, de asemenea, mai multă flexibilitate și control asupra implementării programului coadă .
Următorul exemplu arată crearea unei structuri de date pentru a reprezenta a coadă în Go.
pachet principalimport 'fmt'
tip Coadă struct {
articole [ ] interfață { }
}
func ( q * Coadă ) Pune în coadă ( interfața articolului { } ) {
q. articole = adăuga ( q. articole , articol )
}
func ( q * Coadă ) Scoateți la coadă ( ) interfață { } {
dacă numai ( q. articole ) == 0 {
întoarcere zero
}
articol := q. articole [ 0 ]
q. articole = q. articole [ 1 : ]
întoarcere articol
}
func ( q * Coadă ) Este gol ( ) bool {
întoarcere numai ( q. articole ) == 0
}
func ( q * Coadă ) mărimea ( ) int {
întoarcere numai ( q. articole )
}
func principal ( ) {
coadă := & Coadă { articole : face ( [ ] interfață { } , 0 ) }
coadă. Pune în coadă ( 'Engleză' )
coadă. Pune în coadă ( 'urdu' )
coadă. Pune în coadă ( 'matematica' )
articol := coadă. Scoateți la coadă ( )
fmt. Println ( articol )
dacă coadă. Este gol ( ) {
fmt. Println ( „Coada este goală” )
}
mărimea := coadă. mărimea ( )
fmt. Println ( „Dimensiunea cozii:” , mărimea )
}
În codul de mai sus, un articol este atașat la felia articolului prin intermediul coadă() metoda, care o mută la sfârșitul coadă . Urmărind Primul intrat, primul ieşit (FIFO) principiu, cel scoateți la coadă() metoda scoate un element din partea din față a coadă si il returneaza. Lungimea feliei articolului este verificată ca parte a Este gol() verificarea metodei pentru a vedea dacă coadă este gol. Prin returnarea lungimii feliei articolelor, Mărimea() metoda returnează curentul coada lui mărimea.
Funcția main() folosește Structură de coadă pentru a crea un nou coadă , adăugați elemente la acesta, eliminați elemente din acesta, determinați dacă coadă este gol și calculați dimensiunea acestuia.
Ieșire
4: Canale
În Go, tipul de canal încorporat poate fi utilizat pentru a implementa a coadă structură de date. Canalul poate fi creat cu o dimensiune de buffer pentru a limita numărul de elemente care pot fi puse în coadă la un moment dat. Pentru a adăuga un element la coadă , poate fi trimis către canal folosind <- operator, în timp ce pentru a elimina un element din coadă, acesta poate fi primit de pe canal folosind același operator.
Această abordare poate fi destul de utilă în situațiile în care accesul concomitent la coadă este necesar, deoarece canalele sunt în mod inerent sigure pentru utilizare concomitentă.
Este esențial să rețineți că canalele Go sunt tastate. Aceasta înseamnă că puteți trimite doar valori de un anumit tip printr-un canal și puteți primi doar valori de același tip de la canal.
Aceasta este o ilustrare a modului de utilizare a unui canal pentru a construi un coadă structura datelor în Go.
pachet principalimport (
'fmt'
'timp'
)
tip Coadă struct {
articole chaninterface { }
}
funcNewQueue ( ) * Coadă {
q := & Coadă {
articole : face ( interfață chan { } ) ,
}
merge q. processItems ( )
întoarcere q
}
func ( q * Coadă ) processItems ( ) {
pentru articol := interval q. articole {
dacă articol == 'Engleză' {
fmt. Println ( „Decodați:” , articol )
}
}
}
func ( q * Coadă ) Pune în coadă ( interfața articolului { } ) {
q. articole <- articol
}
funcmain ( ) {
coadă := NewQueue ( )
coadă. Pune în coadă ( 'Engleză' )
coadă. Pune în coadă ( 'urdu' )
coadă. Pune în coadă ( 'matematica' )
timp . Dormi ( 2 * timp . Al doilea )
}
Codul de mai sus creează un Structură de coadă cu un singur câmp articole care este un canal de interfață{} tip. The NewQueue() funcția creează o nouă instanță a Coadă și își inițializează „articole” câmp cu un nou canal fără tampon. De asemenea, pornește o nouă rutină pentru a procesa articolele adăugate la coadă folosind processItems() funcţie. The processItems() funcția verifică dacă elementul primit este egal cu 'Engleză' și imprimă un mesaj pe consolă doar pentru acel articol. The coadă() funcția este utilizată pentru a adăuga elemente noi în coadă.
Ieșire
Concluzie
Coada este o structură de date esențială în Go, folosită pentru a stoca și a prelua elemente într-o anumită ordine. Implementarea a coadă in Go este thread-safe, ceea ce le face o alegere ideală pentru implementarea concurenței în programe. Poate fi implementat folosind felii, liste legate, structuri și canale. Detaliile complete sunt deja furnizate în instrucțiunile de mai sus.