Kas ir rinda?
Astes ir datu struktūras, ko izmanto, lai saglabātu un izgūtu elementus iepriekš noteiktā secībā. Tā ir lineāra datu struktūra, kas atgādina kaudzi un atbilst FIFO (pirmais iekšā, pirmais ārā) noteikums. To var salīdzināt ar gaidīšanas sarakstu vai rindu, kurā pirmais tiek apkalpots pirmais, kurš ierodas. Esošās sastāvdaļas tiek nomestas no priekšpuses rindā , un aizmugurē ir pievienoti jauni elementi.
Rindas ieviešana Golangā
Īstenojot a rindā in Go ir vienkārša un efektīva, un to var ieviest, izmantojot šādas četras metodes.
1: šķēles
In Go, a šķēle ir dinamisks masīvs, kura izmērs var mainīties. Lai īstenotu a rindā izmantojot a šķēle , mēs varam pievienot elementus aizmugurē šķēle izmantojot iebūvēto pievienošanas funkciju un noņemiet elementus no priekšpuses šķēle izmantojot sagriešanu.
Šo pieeju ir viegli izveidot, un tā nodrošina labu pievienošanas un sagriešanas darbību veiktspēju, pateicoties Go iebūvētajām šķēlītēm. Tomēr sadalīšanas metode, kas ietver elementu kopēšanu jaunā pamatā esošā masīvā, var kļūt neefektīva, ja rindā paplašina un prasa atkārtotas rindas noņemšanas darbības.
Šis kods definē rindā ieviešanu, izmantojot sadaļā Go.
galvenā pakete
imports 'fmt'
galvenā funkcija ( ) {
rindā := veidot ( [ ] saskarne { } , 0 )
rindā = pievienot ( rindā , 'Angļu' )
rindā = pievienot ( rindā , 'urdu' )
rindā = pievienot ( rindā , 'matemātika' )
ja tikai ( rindā ) > 0 {
lieta := rindā [ 0 ]
rindā = rindā [ 1 : ]
fmt. Println ( lieta )
}
ja tikai ( rindā ) == 0 {
fmt. Println ( 'Rinda ir tukša' )
} cits {
fmt. Println ( rindā )
}
}
Iepriekš minētais Go kods izmanto šķēli, lai izveidotu vienkāršu rindā datu struktūra. The pievienot () funkcija tiek izmantota, lai ievietotu elementus rindā rindā šķēle, un to noņemšanai no rindas tiek izmantota šķēluma darbība, kas noņem sākotnējo elementu. Ar fmt.Println() , tiek izdrukāts rindas elements. Pēc tam kods izmanto tikai() funkcija, lai noteiktu, vai rinda ir tukša, un, ja tā ir, tā raksta ' Rinda ir tukšs”, izmantojot funkciju fmt.Println().
Izvade
2. Saistītie saraksti
Mezgli, kuriem ir vērtība un rādītājs uz nākamo mezglu sarakstā, veido saistīto sarakstu. Izmantojot divus rādītājus, no kuriem viens norāda uz saraksta priekšpusi (galvu), bet otrs uz aizmuguri (asti), mēs varam ieviest rindā izmantojot saistīto sarakstu. Vienuma noņemšana no rindas (rindas noņemšana) ietver mezgla noņemšanu saraksta sākumā, savukārt vienuma pievienošana rindai (rindas iestatīšana) ietver jauna mezgla pievienošanu saraksta aizmugurē.
Šī metode ļauj veikt efektīvas rindas un rindas noņemšanas darbības, jo ir jāmaina tikai galvenās un astes norādes, pretstatā risinājumam, kas balstīts uz šķēlumiem, kur elementi būtu jākopē.
Izmantojiet saistīto sarakstu, lai ieviestu a rindā izmantojot tālāk norādīto kodu:
galvenā paketeimports 'fmt'
tipa Node struktūra {
vērtību saskarne { }
Nākamais * Mezgls
}
ierakstiet rinda struktūra {
galvu * Mezgls
asti * Mezgls
}
galvenā funkcija ( ) {
rindā := & Rinda { galvu : nulle , asti : nulle }
newNode := & Mezgls { vērtību : 'Angļu' , Nākamais : nulle }
rindā. asti = newNode
rindā. galvu = newNode
newNode = & Mezgls { vērtību : 'urdu' , Nākamais : nulle }
rindā. asti . Nākamais = newNode
rindā. asti = newNode
newNode = & Mezgls { vērtību : 'matemātika' , Nākamais : nulle }
rindā. asti . Nākamais = newNode
rindā. asti = newNode
ja rindā. galvu != nulle {
lieta := rindā. galvu . vērtību
rindā. galvu = rindā. galvu . Nākamais
fmt. Println ( lieta )
}
ja rindā. galvu == nulle {
fmt. Println ( 'Rinda ir tukša' )
}
}
Mezglu struktūra attēlo katru rindā esošo vienumu un satur divus laukus: vērtības lauku, lai saglabātu vienuma vērtību, un nākamo lauku, lai norādītu uz nākamo rindā esošo vienumu. Struktūra Queue izmanto galvas un astes rekvizītus, lai izsekotu attiecīgi rindas priekšpusei un aizmugurei. The astes pirmais postenis ir norādīts ar galvas īpašību, savukārt tā pēdējais vienums ir norādīts ar astes īpašību.
Galvas un astes parametri sākotnēji ir iestatīti uz nulle kad jauns rindā ir izveidots funkcijā main(). Galvas un astes rādītāji ir atjaunināti, lai pievienotu trīs mezglus rindā ar vērtībām “angļu”, “urdu”, un 'matemātika'. The 'Angļu' prece ir tad “atlikts no rindas” (noņemts) no priekšpuses rindā parādot tā vērtību un virzot galvas rādītāju uz nākamo mezglu rindā . Ja pēc izņemšanas no rindas virsraksts kļūst nulle, tas nozīmē, ka rinda ir tukša un tiek parādīts ziņojums ' Rinda ir tukšs” tiek izdrukāts.
Izvade
3: Struktūras
Programmā Go varat izveidot pielāgotu datu struktūru, ko sauc par a struktūra pārstāvēt a rindā . Šis struktūra var būt lauki, lai saglabātu rindā elementi un metodes vienumu pievienošanai un noņemšanai, pārbaudiet, vai rinda ir tukša, un iegūstiet pašreizējo rindas lielumu.
Šis veids, kā izveidot a rindā in Go piedāvā ērtu un iekapsulētu ieviešanu ar viegli lietojamām metodēm, kuras var paplašināt un pielāgot ar vairākām funkcijām. Tā ir elastīga pieeja, kas ļauj veikt izmaiņas ieviešanā vai pievienot jaunas iespējas, kad vien nepieciešams.
Pielāgojuma izveide struktūra ar metodēm ietver papildu koda rakstīšanu salīdzinājumā ar pārējiem diviem veidiem, kas var palielināt sarežģītību. Tomēr tas nodrošina arī lielāku elastību un kontroli pār ieviešanu rindā .
Šis piemērs parāda datu struktūras izveidi, lai attēlotu a rindā sadaļā Go.
galvenā paketeimports 'fmt'
ierakstiet rinda struktūra {
preces [ ] saskarne { }
}
func ( q * Rinda ) Rindā ( vienuma saskarne { } ) {
q. preces = pievienot ( q. preces , lieta )
}
func ( q * Rinda ) Atkāpties no rindas ( ) saskarne { } {
ja tikai ( q. preces ) == 0 {
atgriezties nulle
}
lieta := q. preces [ 0 ]
q. preces = q. preces [ 1 : ]
atgriezties lieta
}
func ( q * Rinda ) Ir tukšs ( ) bool {
atgriezties tikai ( q. preces ) == 0
}
func ( q * Rinda ) Izmērs ( ) starpt {
atgriezties tikai ( q. preces )
}
galvenā funkcija ( ) {
rindā := & Rinda { preces : veidot ( [ ] saskarne { } , 0 ) }
rindā. Rindā ( 'Angļu' )
rindā. Rindā ( 'urdu' )
rindā. Rindā ( 'matemātika' )
lieta := rindā. Atkāpties no rindas ( )
fmt. Println ( lieta )
ja rindā. Ir tukšs ( ) {
fmt. Println ( 'Rinda ir tukša' )
}
Izmērs := rindā. Izmērs ( )
fmt. Println ( 'Rindas lielums:' , Izmērs )
}
Iepriekš minētajā kodā vienums tiek pievienots vienuma sadaļai, izmantojot Rinda () metodi, kas pārvieto to uz beigām rindā . Sekojot Pirmais iekšā, pirmais ārā (FIFO) princips, Izlikt rindu () metode izņem priekšmetu no priekšpuses rindā un atdod to. Preces daļas garums tiek pārbaudīts kā daļa no Ir tukšs() metodi pārbaudiet, vai rindā ir tukšs. Atgriežot priekšmetu šķēles garumu, Izmērs() metode atgriež strāvu astes Izmērs.
Funkcija main () izmanto Rindas struktūra lai izveidotu jaunu rindā , pievienojiet tam elementus, noņemiet vienumus no tā, nosakiet, vai rindā ir tukšs, un aprēķiniet tā lielumu.
Izvade
4: kanāli
Programmā Go iebūvēto kanāla veidu var izmantot, lai ieviestu a rindā datu struktūra. Kanālu var izveidot ar bufera lielumu, lai ierobežotu elementu skaitu, ko var ievietot rindā jebkurā laikā. Lai pievienotu elementu rindā , to var nosūtīt uz kanālu, izmantojot <- operators, savukārt, lai noņemtu elementu no rindas, to var saņemt no kanāla, izmantojot to pašu operatoru.
Šī pieeja var būt ļoti noderīga situācijās, kad vienlaicīga piekļuve rindā ir nepieciešams, jo kanāli pēc būtības ir droši vienlaicīgai lietošanai.
Ir ļoti svarīgi atcerēties, ka Go kanāli tiek drukāti. Tas nozīmē, ka caur kanālu varat nosūtīt tikai noteikta veida vērtības, un no kanāla varat saņemt tikai tāda paša veida vērtības.
Šis ir piemērs tam, kā izmantot kanālu, lai izveidotu a rindā datu struktūra Go.
galvenā paketeimports (
'fmt'
'laiks'
)
ierakstiet rinda struktūra {
priekšmetu kanāla interfeiss { }
}
funcNewQueue ( ) * Rinda {
q := & Rinda {
preces : veidot ( chan interfeiss { } ) ,
}
iet q. processPreces ( )
atgriezties q
}
func ( q * Rinda ) processPreces ( ) {
priekš lieta := diapazons q. preces {
ja lieta == 'Angļu' {
fmt. Println ( 'Atlikts no rindas:' , lieta )
}
}
}
func ( q * Rinda ) Rindā ( vienuma saskarne { } ) {
q. preces <- lieta
}
funcmain ( ) {
rindā := NewQueue ( )
rindā. Rindā ( 'Angļu' )
rindā. Rindā ( 'urdu' )
rindā. Rindā ( 'matemātika' )
laiks . Gulēt ( 2 * laiks . Otrkārt )
}
Iepriekš minētais kods rada a Rindas struktūra ar vienu lauku preces kas ir kanāls saskarne{} veids. The NewQueue() funkcija izveido jaunu instanci Rinda un inicializē to 'preces' lauks ar jaunu nebuferētu kanālu. Tas arī sāk jaunu gorutīnu, lai apstrādātu vienumus, kas pievienoti rindai, izmantojot processItems() funkciju. The processItems() funkcija pārbauda, vai saņemtā prece ir vienāda ar 'Angļu' un izdrukā ziņojumu konsolei tikai par šo vienumu. The Rinda () funkcija tiek izmantota, lai rindai pievienotu jaunus vienumus.
Izvade
Secinājums
Rinda ir būtiska Go datu struktūra, ko izmanto, lai saglabātu un izgūtu elementus noteiktā secībā. Īstenojot a rindā in Go ir pavedienu droša, padarot tos par ideālu izvēli, lai programmās ieviestu vienlaicīgumu. To var ieviest, izmantojot šķēles, saistītos sarakstus, struktūras un kanālus. Pilna informācija jau ir sniegta iepriekš sniegtajās vadlīnijās.