Mikä on jono?
Hännät ovat tietorakenteita, joita käytetään elementtien tallentamiseen ja hakemiseen ennalta määrätyssä järjestyksessä. Se on lineaarinen tietorakenne, joka muistuttaa pinoa ja noudattaa sitä FIFO (First-In, First-Out) sääntö. Sitä voidaan verrata jonotuslistaan tai jonoon, jossa ensimmäisenä saapuva henkilö palvellaan ensimmäisenä. Olemassa olevat komponentit pudotetaan laitteen etuosasta jonottaa , ja takaosaan on lisätty uusia elementtejä.
Jonon käyttöönotto Golangissa
Toteutus a jonottaa in Go on yksinkertainen ja tehokas, ja se voidaan toteuttaa seuraavilla neljällä menetelmällä.
1: Viipaleita
In Go, a viipale on dynaaminen taulukko, jonka koko voi muuttua. Toteuttaaksesi a jonottaa käyttää viipale , voimme lisätä elementtejä takaosaan viipale käyttämällä sisäänrakennettua append-toimintoa ja poista elementit etupuolelta viipale käyttämällä viipalointia.
Tämä lähestymistapa on helppo rakentaa, ja se tarjoaa hyvän suorituskyvyn lisäys- ja viipalointitoimintoihin Go:n sisäänrakennettujen viipaleiden ansiosta. Viipalointimenetelmä, joka sisältää elementtien kopioimisen uuteen taustalla olevaan taulukkoon, voi kuitenkin tulla tehottomaksi, jos jonottaa laajenee ja vaatii toistuvia jonotustoimenpiteitä.
Seuraava koodi määrittelee jonottaa toteutus Go:n sliceillä.
pääpaketti
tuonti 'fmt'
func main ( ) {
jonottaa := tehdä ( [ ] käyttöliittymä { } , 0 )
jonottaa = liittää ( jonottaa , 'Englanti' )
jonottaa = liittää ( jonottaa , 'urdu' )
jonottaa = liittää ( jonottaa , 'matematiikka' )
jos vain ( jonottaa ) > 0 {
kohde := jonottaa [ 0 ]
jonottaa = jonottaa [ 1 : ]
fmt. Println ( kohde )
}
jos vain ( jonottaa ) == 0 {
fmt. Println ( 'Jono on tyhjä' )
} muu {
fmt. Println ( jonottaa )
}
}
Yllä oleva Go-koodi käyttää viipaletta suoraviivaisen koodin rakentamiseen jonottaa tietorakenne. The liitä() -funktiota käytetään elementtien jonoon lisäämiseen jonottaa slice, ja slice-toimintoa, joka poistaa alkuperäisen elementin, käytetään niiden poistamiseen. Kanssa fmt.Println() , jonosta poistettu elementti tulostetaan. Koodi käyttää sitten vain() toiminto määrittää, onko jono tyhjä, ja jos on, se kirjoittaa ' Jonottaa on tyhjä” fmt.Println()-funktiolla.
Lähtö
2: Linkitetyt luettelot
Solmut, joissa on arvo ja osoitin luettelon seuraavaan solmuun, muodostavat linkitetyn luettelon. Kahdella osoittimella, joista toinen osoittaa luettelon etuosaan (pää) ja toinen taakse (häntä), voimme toteuttaa jonottaa linkitetyn luettelon avulla. Kohteen poistaminen jonosta (jonon poistaminen) sisältää luettelon etuosassa olevan solmun poistamisen, kun taas kohteen lisääminen jonoon (jonottaminen) sisältää uuden solmun lisäämisen luettelon takaosaan.
Tämä menetelmä mahdollistaa tehokkaat jonotus- ja purkutoiminnot, koska vain pää- ja loppuosoittimia tarvitsee muuttaa, toisin kuin viipalepohjaisessa ratkaisussa, jossa elementtejä pitäisi kopioida.
Käytä linkitettyä luetteloa toteuttaaksesi a jonottaa käyttämällä alla olevaa koodia:
pääpakettituonti 'fmt'
tyyppi Node struct {
arvo käyttöliittymä { }
Seuraava * Solmu
}
kirjoita Jono struct {
pää * Solmu
häntää * Solmu
}
func main ( ) {
jonottaa := & Jonottaa { pää : nolla , häntää : nolla }
newNode := & Solmu { arvo : 'Englanti' , Seuraava : nolla }
jonottaa. häntää = newNode
jonottaa. pää = newNode
newNode = & Solmu { arvo : 'urdu' , Seuraava : nolla }
jonottaa. häntää . Seuraava = newNode
jonottaa. häntää = newNode
newNode = & Solmu { arvo : 'matematiikka' , Seuraava : nolla }
jonottaa. häntää . Seuraava = newNode
jonottaa. häntää = newNode
jos jonottaa. pää != nolla {
kohde := jonottaa. pää . arvo
jonottaa. pää = jonottaa. pää . Seuraava
fmt. Println ( kohde )
}
jos jonottaa. pää == nolla {
fmt. Println ( 'Jono on tyhjä' )
}
}
Solmurakenne edustaa jokaista jonon alkiota ja sisältää kaksi kenttää: arvokentän kohteen arvon tallentamiseen ja seuraavan kentän, joka osoittaa jonon seuraavaan kohteeseen. Queue-rakenne käyttää head- ja tail-ominaisuuksia seuratakseen jonon etu- ja takaosaa. The hännän ensimmäinen kohde osoitetaan head-ominaisuuden avulla, kun taas sen viimeinen kohde on merkitty häntäominaisuuteen.
Pää- ja hännänparametrit asetetaan aluksi nolla kun uusi jonottaa on määritetty main()-funktiossa. Pää- ja hännänosoittimet päivitetään lisäämään kolme solmua jonottaa arvojen kanssa 'englanti', 'urdu', ja 'matematiikka'. The 'Englanti' kohde on sitten 'jonosta poistettu' (poistettu) etuosasta jonottaa näyttämällä sen arvon ja siirtämällä pääosoittimen seuraavaan solmuun jonottaa . Jos pää muuttuu tyhjäksi jonotuksen jälkeen, se tarkoittaa, että jono on tyhjä ja viesti ' Jonottaa on tyhjä” tulostetaan.
Lähtö
3: Rakenteet
Gossa voit luoda mukautetun tietorakenteen nimeltä a struct edustamaan a jonottaa . Tämä struct voi olla kenttiä tallentaa jonottaa elementtejä ja tapoja lisätä ja poistaa kohteita, tarkistaa, onko jono tyhjä, ja saada nykyinen jonon koko.
Tämä tapa luoda a jonottaa in Go tarjoaa kätevän ja kapseloidun toteutuksen helppokäyttöisillä menetelmillä, joita voidaan laajentaa ja mukauttaa lisäominaisuuksilla. Se on joustava lähestymistapa, joka mahdollistaa muutosten tekemisen toteutukseen tai uusien ominaisuuksien lisäämisen aina tarvittaessa.
Mukautetun luominen struct menetelmien kanssa sisältää lisäkoodin kirjoittamisen kahteen muuhun tapaan verrattuna, mikä voi lisätä monimutkaisuutta. Se tarjoaa kuitenkin myös enemmän joustavuutta ja hallinnan täytäntöönpanoa jonottaa .
Seuraava esimerkki näyttää tietorakenteen luomisen edustamaan a jonottaa kohdassa Go.
pääpakettituonti 'fmt'
kirjoita Jono struct {
kohteita [ ] käyttöliittymä { }
}
func ( q * Jonottaa ) Jono ( kohteen käyttöliittymä { } ) {
q. kohteita = liittää ( q. kohteita , kohde )
}
func ( q * Jonottaa ) Poistaa jonosta ( ) käyttöliittymä { } {
jos vain ( q. kohteita ) == 0 {
palata nolla
}
kohde := q. kohteita [ 0 ]
q. kohteita = q. kohteita [ 1 : ]
palata kohde
}
func ( q * Jonottaa ) On tyhjä ( ) bool {
palata vain ( q. kohteita ) == 0
}
func ( q * Jonottaa ) Koko ( ) int {
palata vain ( q. kohteita )
}
func main ( ) {
jonottaa := & Jonottaa { kohteita : tehdä ( [ ] käyttöliittymä { } , 0 ) }
jonottaa. Jono ( 'Englanti' )
jonottaa. Jono ( 'urdu' )
jonottaa. Jono ( 'matematiikka' )
kohde := jonottaa. Poistaa jonosta ( )
fmt. Println ( kohde )
jos jonottaa. On tyhjä ( ) {
fmt. Println ( 'Jono on tyhjä' )
}
koko := jonottaa. Koko ( )
fmt. Println ( 'Jonon koko:' , koko )
}
Yllä olevassa koodissa nimike on liitetty kohteen osaan Enqueue() menetelmä, joka siirtää sen loppuun jonottaa . Seuraamalla Ensimmäinen sisään, ensimmäinen ulos (FIFO) periaate, Tyhjennä () menetelmä ottaa kohteen ulos etupuolelta jonottaa ja palauttaa sen. Tuotteen viipaleen pituus tarkistetaan osana On tyhjä() menetelmä tarkistaa, onko jonottaa on tyhjä. Palauttamalla kohteiden viipaleen pituuden, Koko() menetelmä palauttaa virran hännän koko.
Main()-funktio käyttää Jonorakenne luodaksesi uuden jonottaa , lisätä siihen elementtejä, poistaa kohteita siitä, määrittää, onko jonottaa on tyhjä, ja laske sen koko.
Lähtö
4: Kanavat
Go:ssa sisäänrakennettua kanavatyyppiä voidaan käyttää toteuttamaan a jonottaa tietorakenne. Kanavaan voidaan luoda puskurin koko, joka rajoittaa jonoon kulloinkin sijoitettavien elementtien määrää. Elementin lisääminen jonottaa , se voidaan lähettää kanavalle käyttämällä <- -operaattori, kun taas elementin poistamiseksi jonosta se voidaan vastaanottaa kanavalta samalla operaattorilla.
Tämä lähestymistapa voi olla varsin hyödyllinen tilanteissa, joissa pääsy samaan aikaan jonottaa tarvitaan, koska kanavat ovat luonnostaan turvallisia samanaikaiseen käyttöön.
On tärkeää muistaa, että Go-kanavat kirjoitetaan. Tämä tarkoittaa, että voit lähettää vain tietyn tyyppisiä arvoja kanavan kautta ja voit vastaanottaa vain samantyyppisiä arvoja kanavasta.
Tämä on esimerkki siitä, kuinka kanavaa käytetään a jonottaa tietorakenne Gossa.
pääpakettituonti (
'fmt'
'aika'
)
kirjoita Jono struct {
kohteiden kanavaliittymä { }
}
funcNewQueue ( ) * Jonottaa {
q := & Jonottaa {
kohteita : tehdä ( chan käyttöliittymä { } ) ,
}
mene q. prosessiesineet ( )
palata q
}
func ( q * Jonottaa ) prosessiesineet ( ) {
varten kohde := alue q. kohteita {
jos kohde == 'Englanti' {
fmt. Println ( 'Jonosta poistettu:' , kohde )
}
}
}
func ( q * Jonottaa ) Jono ( kohteen käyttöliittymä { } ) {
q. kohteita <- kohde
}
funcmain ( ) {
jonottaa := NewQueue ( )
jonottaa. Jono ( 'Englanti' )
jonottaa. Jono ( 'urdu' )
jonottaa. Jono ( 'matematiikka' )
aika . Nukkua ( 2 * aika . Toinen )
}
Yllä oleva koodi luo a Jonorakenne yhdellä kentällä kohteita joka on kanava käyttöliittymä{} tyyppi. The Uusi jono() funktio luo uuden esiintymän Jonottaa ja alustaa sen 'esineet' kenttään uudella puskuroimattomalla kanavalla. Se myös käynnistää uuden gorutiinin jonoon lisättyjen kohteiden käsittelemiseksi käyttämällä Procesitems() toiminto. The Procesitems() toiminto tarkistaa, onko vastaanotettu kohde yhtä suuri kuin 'Englanti' ja tulostaa viestin konsoliin vain kyseisestä kohteesta. The Enqueue() -toimintoa käytetään lisäämään uusia kohteita jonoon.
Lähtö
Johtopäätös
Jono on olennainen Go:n tietorakenne, jota käytetään elementtien tallentamiseen ja hakemiseen tietyssä järjestyksessä. Toteutus a jonottaa in Go on lankaturvallinen, joten ne ovat ihanteellinen valinta ohjelmien samanaikaisuuden toteuttamiseen. Se voidaan toteuttaa käyttämällä viipaleita, linkitettyjä listoja, rakenteita ja kanavia. Täydelliset tiedot on jo annettu yllä annetuissa ohjeissa.