Mis on järjekord Golangis?

Go on populaarne programmeerimiskeel, mida kiidetakse selle tõhususe, kasutuslihtsuse ja kohanemisvõime eest. Rikkaliku tööriistade ja teekide komplektiga pakub Go arendajatele võimsate ja tõhusate tarkvararakenduste loomiseks vajalikke ressursse. Kuigi Go ei oma sabad oma standardteegis andmestruktuurina saab neid realiseerida erinevate meetodite abil. Räägime kontseptsioonist sabad ja kuidas neid selles õpetuses rakendada.

Mis on järjekord?

Sabad on andmestruktuurid, mida kasutatakse elementide salvestamiseks ja toomiseks etteantud järjekorras. See on lineaarne andmestruktuur, mis sarnaneb virnaga ja järgib FIFO (first-in, First-Out) reegel. Seda võib võrrelda ootenimekirja või liiniga, kus esimesena saabujat teenindatakse. Olemasolevad komponendid kukutatakse seadme esiosast maha järjekorda , ja tagaküljele lisatakse uusi elemente.

Järjekorra rakendamine Golangis

Rakendamine a järjekorda in Go on lihtne ja tõhus ning seda saab rakendada järgmise nelja meetodi abil.

Viilud
Lingitud loendid
Struktuurid
Kanalid

1: viilud

In Go, a viil on dünaamiline massiiv, mille suurus võib muutuda. Rakendada a järjekorda kasutades a viil , saame lisada elemente tagaküljele viil kasutades sisseehitatud lisamisfunktsiooni ja eemaldage elemendid esiosast viil viilutamist kasutades.

Seda lähenemisviisi on lihtne ehitada ja see pakub tänu Go sisseehitatud viiludele head jõudlust lisamiseks ja viilutamiseks. Kuid viilutamismeetod, mis hõlmab elementide kopeerimist uude alusmassiivi, võib muutuda ebaefektiivseks, kui järjekorda laieneb ja nõuab korduvaid järjekordadest vabastamise toiminguid.

Järgmine kood määratleb järjekorda rakendamine, kasutades Go-s lõiku.

pakett peamine

importida 'fmt'

func main ( ) {

järjekorda := tegema ( [ ] liides { } , 0 )

järjekorda = lisama ( järjekorda , 'Inglise' )

järjekorda = lisama ( järjekorda , 'urdu' )

järjekorda = lisama ( järjekorda , 'matemaatika' )

kui ainult ( järjekorda ) > 0 {

üksus := järjekorda [ 0 ]

järjekorda = järjekorda [ 1 : ]

fmt. Println ( üksus )

}

kui ainult ( järjekorda ) == 0 {

fmt. Println ( 'Järjekord on tühi' )

} muidu {

fmt. Println ( järjekorda )

}

}

Ülaltoodud Go-kood kasutab sirgjoone loomiseks lõiku järjekorda andmete struktuur. The lisa () funktsiooni kasutatakse elementide järjestamiseks järjekorda slice ja nende järjekorrast eemaldamiseks kasutatakse viiluoperatsiooni, mis eemaldab esialgse elemendi. Koos fmt.Println() , prinditakse järjekorrast eemaldatud element. Seejärel kasutab kood ainult() funktsioon, et teha kindlaks, kas järjekord on tühi, ja kui on, siis kirjutab ' Järjekord on tühi”, kasutades funktsiooni fmt.Println().

Väljund

2: Lingitud loendid

Sõlmed, mis kannavad väärtust ja kursorit loendis järgmisele sõlmele, moodustavad lingitud loendi. Kahe osutiga, millest üks osutab loendi ette (pea) ja teine taha (saba), saame rakendada järjekorda kasutades lingitud loendit. Üksuse eemaldamine järjekorrast (järjekorrast vabastamine) hõlmab loendi esiosas oleva sõlme eemaldamist, samas kui üksuse järjekorda lisamine (järjekorda seadmine) hõlmab uue sõlme lisamist loendi taha.

See meetod võimaldab tõhusaid järjekorda seadmise ja järjekorra eemaldamise toiminguid, sest erinevalt lõigupõhisest lahendusest, kus elemente oleks vaja kopeerida, tuleb muuta ainult pea- ja sabaosuleid.

Kasutage lingitud loendit, et rakendada a järjekorda kasutades allolevat koodi:

pakett peamine

importida 'fmt'

tüüp Node struktuur {

väärtusliides { }

järgmiseks * Sõlm

}

tippige Queue struktuur {

pea * Sõlm

saba * Sõlm

}

func main ( ) {

järjekorda := & Järjekord { pea : null , saba : null }

uusSõlm := & Sõlm { väärtus : 'Inglise' , järgmiseks : null }

järjekorda. saba = uusSõlm

järjekorda. pea = uusSõlm

uusSõlm = & Sõlm { väärtus : 'urdu' , järgmiseks : null }

järjekorda. saba . järgmiseks = uusSõlm

järjekorda. saba = uusSõlm

uusSõlm = & Sõlm { väärtus : 'matemaatika' , järgmiseks : null }

järjekorda. saba . järgmiseks = uusSõlm

järjekorda. saba = uusSõlm

kui järjekorda. pea != null {

üksus := järjekorda. pea . väärtus

järjekorda. pea = järjekorda. pea . järgmiseks

fmt. Println ( üksus )

}

kui järjekorda. pea == null {

fmt. Println ( 'Järjekord on tühi' )

}

}

Struktuur Node esindab iga üksust järjekorras ja sisaldab kahte välja: väärtuse väli üksuse väärtuse salvestamiseks ja järgmine väli järjekorras järgmisele üksusele osutamiseks. Struktuur Queue kasutab pea ja saba atribuute, et jälgida vastavalt järjekorra esi- ja tagaosa. The saba oma esimene üksus on tähistatud pea omadusega, viimane üksus aga saba omadusega.

Pea ja saba parameetrid on algselt seatud null kui uus järjekorda on määratud funktsioonis main(). Pea- ja sabaosuleid värskendatakse, et lisada sellele kolm sõlme järjekorda väärtustega 'inglise', 'urdu', ja 'matemaatika'. The 'Inglise' ese on siis 'järjekorrast maha võetud' (eemaldatud) esiosast järjekorda kuvades selle väärtuse ja nihutades peakursori järgmisele sõlmele järjekorda . Kui pärast järjekorra eemaldamist muutub pea nulliks, tähendab see, et järjekord on tühi ja teade ' Järjekord on tühi” trükitakse.

Väljund

3: struktuurid

Rakenduses Go saate luua kohandatud andmestruktuuri nimega a struktuur esindama a järjekorda . See struktuur võivad olla väljad salvestamiseks järjekorda elemendid ja meetodid üksuste lisamiseks ja eemaldamiseks, kontrollige, kas järjekord on tühi, ja hankige praegune järjekorra suurus.

See viis luua a järjekorda in Go pakub mugavat ja kapseldatud teostust koos hõlpsasti kasutatavate meetoditega, mida saab laiendada ja kohandada rohkemate funktsioonidega. See on paindlik lähenemine, mis võimaldab vajaduse korral juurutusse muudatusi teha või uusi võimalusi lisada.

Kohandatud loomine struktuur meetodite puhul hõlmab kahe teise viisiga võrreldes täiendava koodi kirjutamine, mis võib keerukamaks muuta. Samas pakub see ka suuremat paindlikkust ja kontrolli selle rakendamise üle järjekorda .

Järgmine näide näitab andmestruktuuri loomist a esindamiseks järjekorda sisse Go.

pakett peamine

importida 'fmt'

tippige Queue struktuur {
esemed [ ] liides { }
}

func ( q * Järjekord ) Järjekord ( üksuse liides { } ) {
q. esemed = lisama ( q. esemed , üksus )
}

func ( q * Järjekord ) Järjekorrast lahkumine ( ) liides { } {
kui ainult ( q. esemed ) == 0 {
tagasi null
}
üksus := q. esemed [ 0 ]
q. esemed = q. esemed [ 1 : ]
tagasi üksus
}

func ( q * Järjekord ) On tühi ( ) bool {
tagasi ainult ( q. esemed ) == 0
}

func ( q * Järjekord ) Suurus ( ) int {
tagasi ainult ( q. esemed )
}

func main ( ) {

järjekorda := & Järjekord { esemed : tegema ( [ ] liides { } , 0 ) }

järjekorda. Järjekord ( 'Inglise' )
järjekorda. Järjekord ( 'urdu' )
järjekorda. Järjekord ( 'matemaatika' )

üksus := järjekorda. Järjekorrast lahkumine ( )
fmt. Println ( üksus )
kui järjekorda. On tühi ( ) {
fmt. Println ( 'Järjekord on tühi' )
}

suurus := järjekorda. Suurus ( )
fmt. Println ( 'Järjekorra suurus:' , suurus )
}

Ülaltoodud koodis lisatakse üksus üksuse lõigule Järjekord() meetod, mis viib selle lõppu järjekorda . Jälgib Esimene sisse, esimene välja (FIFO) põhimõte, Tühista () meetod võtab üksuse esiosast välja järjekorda ja tagastab selle. Kauba lõigu pikkust kontrollitakse osana On tühi() meetodi abil kontrollige, kas järjekorda on tühi. Kui tagastate esemete lõigu pikkuse, siis Suurus () meetod tagastab voolu saba oma suurus.

Funktsioon main() kasutab Järjekorra struktuur uue loomiseks järjekorda , lisage sellele elemente, eemaldage sellest üksusi, tehke kindlaks, kas järjekorda on tühi ja arvutage selle suurus.

Väljund

4: kanalid

Go-s saab sisseehitatud kanalitüüpi kasutada a rakendamiseks järjekorda andmestruktuur. Kanali saab luua puhvri suurusega, et piirata elementide arvu, mida saab igal ajahetkel järjekorda panna. Elemendi lisamiseks järjekorda , saab selle kanalile saata kasutades <- operaator, samas kui elemendi järjekorrast eemaldamiseks saab selle sama operaatorit kasutades kanalilt vastu võtta.

See lähenemine võib olla üsna kasulik olukordades, kus samaaegne juurdepääs järjekorda on vajalik, kuna kanalid on oma olemuselt samaaegseks kasutamiseks ohutud.

Oluline on meeles pidada, et Go kanalid on trükitud. See tähendab, et saate kanali kaudu saata ainult kindlat tüüpi väärtusi ja kanalilt saate vastu võtta ainult sama tüüpi väärtusi.

See on näide sellest, kuidas kasutada kanalit a konstrueerimiseks järjekorda Go andmestruktuur.

pakett peamine

importida (
'fmt'
'aeg'
)

tippige Queue struktuur {
üksuste kanalite liides { }
}

funcNewQueue ( ) * Järjekord {

q := & Järjekord {

esemed : tegema ( chan liides { } ) ,
}
mine q. töödelda esemeid ( )
tagasi q
}

func ( q * Järjekord ) töödelda esemeid ( ) {
jaoks üksus := vahemik q. esemed {
kui üksus == 'Inglise' {
fmt. Println ( 'Järjest maha võetud:' , üksus )
}
}
}

func ( q * Järjekord ) Järjekord ( üksuse liides { } ) {

q. esemed <- üksus

}

funcmain ( ) {
järjekorda := UusJärjekord ( )

järjekorda. Järjekord ( 'Inglise' )
järjekorda. Järjekord ( 'urdu' )
järjekorda. Järjekord ( 'matemaatika' )

aega . Magama ( 2 * aega . Teiseks )
}

Ülaltoodud kood loob a Järjekorra struktuur ühe väljaga esemed mis on kanal liides{} tüüp. The Uus järjekord() funktsioon loob uue eksemplari Järjekord ja initsialiseerib selle 'esemed' välja uue puhverdamata kanaliga. Samuti käivitab see uue gorutiini, et töödelda järjekorda lisatud üksusi kasutades protsessItems() funktsiooni. The protsessItems() funktsioon kontrollib, kas vastuvõetud üksus on võrdne 'Inglise' ja prindib konsooli ainult selle üksuse kohta teate. The Järjekord() funktsiooni kasutatakse uute üksuste lisamiseks järjekorda.

Väljund

Järeldus

Järjekord on Go oluline andmestruktuur, mida kasutatakse elementide salvestamiseks ja toomiseks kindlas järjekorras. Rakendamine a järjekorda in Go on lõimekindel, muutes need ideaalseks valikuks samaaegsuse rakendamiseks programmides. Seda saab rakendada lõikude, lingitud loendite, struktuuride ja kanalite abil. Kõik üksikasjad on juba esitatud ülaltoodud juhistes.

Mis on järjekord Golangis?