Mi az a várólista?
Frakk olyan adatstruktúrák, amelyek az elemek előre meghatározott sorrendben történő tárolására és lekérésére szolgálnak. Ez egy lineáris adatstruktúra, amely egy veremre hasonlít, és ragaszkodik a FIFO (First-In, First-Out) szabály. Ez egy várólistához vagy egy olyan sorhoz hasonlítható, ahol az elsőként érkezőt szolgálják ki először. A meglévő alkatrészeket leejtik a készülék elejéről sorban , és új elemekkel bővül a hátlap.
Várólista megvalósítása Golangban
A megvalósítás a sorban in Go egyszerű és hatékony, és a következő négy módszerrel valósítható meg.
1: Szeletek
In Go, a szelet egy dinamikus tömb, amelynek mérete változhat. A megvalósításhoz a sorban használva szelet , elemeket adhatunk a hátuljához szelet a beépített hozzáfűzés funkcióval, és távolítsa el az elemeket az előlapról szelet szeletelés segítségével.
Ezt a megközelítést könnyű felépíteni, és a Go beépített szeleteinek köszönhetően jó teljesítményt nyújt a hozzáfűzési és szeletelési műveletekhez. Azonban a szeletelési módszer, amely magában foglalja az elemek másolását egy új mögöttes tömbbe, hatástalanná válhat, ha a sorban kiterjeszti, és ismételt sormentesítési műveleteket tesz szükségessé.
A következő kód határozza meg a sorban megvalósítása egy szelet segítségével a Go-ban.
csomag fő
import 'fmt'
func main ( ) {
sorban := készítsenek ( [ ] felület { } , 0 )
sorban = mellékel ( sorban , 'angol' )
sorban = mellékel ( sorban , 'urdu' )
sorban = mellékel ( sorban , 'matematika' )
ha csak ( sorban ) > 0 {
tétel := sorban [ 0 ]
sorban = sorban [ 1 : ]
fmt. Println ( tétel )
}
ha csak ( sorban ) == 0 {
fmt. Println ( 'A sor üres' )
} más {
fmt. Println ( sorban )
}
}
A fenti Go-kód egy szeletet használ az egyszerű összeállításhoz sorban adatszerkezet. A mellékel() függvény az elemek sorba rendezésére szolgál sorban slice, és egy szeletműveletet használnak, amely eltávolítja a kezdeti elemet a sorból való törlésükre. Val vel fmt.Println() , a sorba állított elem kinyomtatásra kerül. A kód ezután a csak() függvény segítségével megállapíthatja, hogy a sor üres-e, és ha az, akkor kiírja: Sor üres” az fmt.Println() függvény használatával.
Kimenet
2: Hivatkozott listák
Az értéket és a lista következő csomópontjára mutató mutatót hordozó csomópontok egy csatolt listát alkotnak. Két mutatóval, az egyik a lista elejére (fejére), a másik a hátuljára (farokra) mutat, megvalósíthatunk egy sorban linkelt lista segítségével. Egy elem eltávolítása a sorból (sorba helyezés) a lista elején lévő csomópont eltávolítását jelenti, míg egy elem hozzáadása a sorhoz (sorba állítás) egy új csomópont hozzáadását jelenti a lista hátuljához.
Ez a módszer lehetővé teszi a hatékony sorbaállítási és sorkiürítési műveleteket, mivel csak a fej- és végmutatókat kell megváltoztatni, szemben a szelet alapú megoldással, ahol az elemeket másolni kell.
Használjon linkelt listát a megvalósításához sorban az alábbi kóddal:
csomag főimport 'fmt'
típusú Node struct {
érték interfész { }
következő * Csomópont
}
írja be a Queue-t struct {
fej * Csomópont
farok * Csomópont
}
func main ( ) {
sorban := & Sor { fej : nulla , farok : nulla }
newNode := & Csomópont { érték : 'angol' , következő : nulla }
sorban. farok = newNode
sorban. fej = newNode
newNode = & Csomópont { érték : 'urdu' , következő : nulla }
sorban. farok . következő = newNode
sorban. farok = newNode
newNode = & Csomópont { érték : 'matematika' , következő : nulla }
sorban. farok . következő = newNode
sorban. farok = newNode
ha sorban. fej != nulla {
tétel := sorban. fej . érték
sorban. fej = sorban. fej . következő
fmt. Println ( tétel )
}
ha sorban. fej == nulla {
fmt. Println ( 'A sor üres' )
}
}
A csomópont-struktúra a sorban lévő összes elemet képviseli, és két mezőt tartalmaz: egy értékmezőt az elem értékének tárolására, a következő mezőt pedig a sorban következő elemre mutat. A Queue struktúra a head és a tail tulajdonságokat használja a sor elejének és hátsó részének nyomon követésére. A frakk Az első tételt a head tulajdonság jelöli, míg az utolsó elemét a farok tulajdonság jelzi.
A fej és a farok paraméterei kezdetben a következőre vannak állítva nulla amikor egy új sorban a main() függvényben jön létre. A fej- és farokmutatók frissítve három csomópontot adnak hozzá sorban az értékekkel „angol”, „urdu”, és 'matematika'. A 'angol' tétel akkor „sorból kiállva” (eltávolítva) az elejéről sorban úgy, hogy megjeleníti az értékét, és a fejmutatót a következő csomópontra viszi a sorban . Ha a sorból való kilépés után a fej nullává válik, az azt jelenti, hogy a sor üres, és a „ Sor üres” jelenik meg.
Kimenet
3: Struktúrák
A Go alkalmazásban létrehozhat egy egyéni adatstruktúrát, melynek neve a struct képviselni a sorban . Ez struct lehetnek mezők a tárolására sorban elemeket és módszereket elemek hozzáadásához és eltávolításához, ellenőrizze, hogy a várólista üres-e, és kérje le a sor aktuális méretét.
Ez a létrehozási mód a sorban Az in Go kényelmes és beágyazott megvalósítást kínál, könnyen használható módszerekkel, amelyek további funkciókkal bővíthetők és testreszabhatók. Ez egy rugalmas megközelítés, amely lehetővé teszi a megvalósítás módosítását vagy új képességek hozzáadását, amikor csak szükséges.
Egyéni létrehozása struct metódusokkal további kód írását jelenti a másik két módszerhez képest, ami növelheti a bonyolultságot. Ugyanakkor nagyobb rugalmasságot és ellenőrzést biztosít a végrehajtása felett sorban .
A következő példa egy adatstruktúra létrehozását mutatja be az a sorban a Go-ban.
csomag főimport 'fmt'
írja be a Queue-t struct {
tételeket [ ] felület { }
}
func ( q * Sor ) Sorba állítás ( tétel interfész { } ) {
q. tételeket = mellékel ( q. tételeket , tétel )
}
func ( q * Sor ) Sorból ( ) felület { } {
ha csak ( q. tételeket ) == 0 {
Visszatérés nulla
}
tétel := q. tételeket [ 0 ]
q. tételeket = q. tételeket [ 1 : ]
Visszatérés tétel
}
func ( q * Sor ) Üres ( ) bool {
Visszatérés csak ( q. tételeket ) == 0
}
func ( q * Sor ) Méret ( ) int {
Visszatérés csak ( q. tételeket )
}
func main ( ) {
sorban := & Sor { tételeket : készítsenek ( [ ] felület { } , 0 ) }
sorban. Sorba állítás ( 'angol' )
sorban. Sorba állítás ( 'urdu' )
sorban. Sorba állítás ( 'matematika' )
tétel := sorban. Sorból ( )
fmt. Println ( tétel )
ha sorban. Üres ( ) {
fmt. Println ( 'A sor üres' )
}
méret := sorban. Méret ( )
fmt. Println ( 'A sor mérete:' , méret )
}
A fenti kódban egy elem hozzá van fűzve az elem szeletéhez a következőn keresztül sor() módszer, amely a végére helyezi azt sorban . Kövesd a First-In, First-Out (FIFO) elv, a Dequeue() metódus kivesz egy elemet az elejéről sorban és visszaadja. Az elem szeletének hosszát a rendszer a Üres() módszerrel ellenőrizze, hogy a sorban üres. Az elemek szelet hosszának visszaadásával a Méret() metódus az áramot adja vissza frakk méret.
A main() függvény a Sorstruktúra új létrehozásához sorban , adjunk hozzá elemeket, távolítsunk el belőle elemeket, határozzuk meg, hogy a sorban üres, és számítsa ki a méretét.
Kimenet
4: Csatornák
A Go-ban a beépített csatornatípus megvalósítható a sorban adatszerkezet. A csatorna létrehozható puffermérettel, hogy korlátozzuk az adott időpontban sorba helyezhető elemek számát. Elem hozzáadásához a sorban segítségével a csatornára küldhető <- operátort, míg a sorból egy elem eltávolításához ugyanazt az operátort használhatja a csatornától.
Ez a megközelítés nagyon hasznos lehet olyan helyzetekben, amikor egyidejű hozzáférés a sorban szükséges, mivel a csatornák természetüknél fogva biztonságosak egyidejű használathoz.
Nagyon fontos megjegyezni, hogy a Go csatornák gépelve vannak. Ez azt jelenti, hogy csak egy adott típusú értékeket küldhet egy csatornán keresztül, és csak az azonos típusú értékeket fogadhatja a csatornáról.
Ez azt szemlélteti, hogyan lehet egy csatornát használni a sorban adatszerkezet a Go-ban.
csomag főimport (
'fmt'
'idő'
)
írja be a Queue-t struct {
elemek csatornafelülete { }
}
funcNewQueue ( ) * Sor {
q := & Sor {
tételeket : készítsenek ( chan interfész { } ) ,
}
menj q. folyamatElemek ( )
Visszatérés q
}
func ( q * Sor ) folyamatElemek ( ) {
számára tétel := tartomány q. tételeket {
ha tétel == 'angol' {
fmt. Println ( 'Várólista:' , tétel )
}
}
}
func ( q * Sor ) Sorba állítás ( tétel interfész { } ) {
q. tételeket <- tétel
}
funcmain ( ) {
sorban := NewQueue ( )
sorban. Sorba állítás ( 'angol' )
sorban. Sorba állítás ( 'urdu' )
sorban. Sorba állítás ( 'matematika' )
idő . Alvás ( 2 * idő . Második )
}
A fenti kód létrehozza a Sorstruktúra egyetlen mezővel tételeket amely csatornája felület{} típus. A NewQueue() függvény új példányt hoz létre a Sor és inicializálja annak „elemek” mező egy új pufferolatlan csatornával. Egy új gorutint is elindít a sorhoz hozzáadott elemek feldolgozásához a processItems() funkció. A processItems() funkció ellenőrzi, hogy a fogadott tétel egyenlő-e 'angol' és csak az adott elemhez nyomtat üzenetet a konzolra. A sor() függvény új elemek hozzáadására szolgál a sorhoz.
Kimenet
Következtetés
A sor a Go egyik alapvető adatszerkezete, amely az elemek meghatározott sorrendben történő tárolására és lekérésére szolgál. A megvalósítás a sorban Az in Go szálbiztos, így ideális választás a programok párhuzamosságának megvalósításához. Szeletek, linkelt listák, struktúrák és csatornák segítségével valósítható meg. A teljes részlet már megtalálható a fent megadott útmutatókban.