Näide 1: Golangi sorteerimine kasvavas järjekorras
Funktsioon 'sort.Slice()' on Go peamine funktsioon, mis korraldab lõigu elemendid ümber kasvavas või kahanevas järjekorras. Võtke arvesse järgmist illustratsiooni, kus viil on järjestatud kasvavas järjekorras:
pakett peamineimportida (
'fmt'
'sorteeri'
)
func peamine () {
isegiSlice := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Sortimata viil:' , isegiSlice )
sorteerida . Viil ( isegiSlice , func ( i , j int ) bool {
tagasi isegiSlice [ i ] < ühtlane Viil [ j ]
})
fmt . Println ( 'Sorteeritud viil:' , isegiSlice )
}
Funktsiooni main() alguses defineerime osa EvenSlice väärtustega {10, 2, 8, 4, 0, 6}. See osa esindab paarisarvude kogumit, mis on algselt sorteerimata. Jaotise evenSlice sortimiseks kasutatakse koos viiluga funktsiooni sort.Slice(). Funktsiooni sort.Slice() sees on argumendina esitatud sortimisfunktsioon. See funktsioon määrab sortimisjärjestuse, võrreldes lõigu kahte elementi indeksite “i” ja “j” juures. Kui paarislõik[i] on väiksem kui paarislõik[j], tagastab see tõene; vastasel juhul tagastab see vale. Funktsioon sort.Slice() kasutab seda võrdlusfunktsiooni lõigu 'evenSlice' elementide ümberpaigutamiseks kasvavas järjekorras.
Sorditud lõigu tulemused kasvavas järjekorras genereeritakse järgmisel väljundekraanil:
Näide 2: Golangi sortimise osa viil
Järgmisena rakendatakse sorteerimine määratud lõigu alamlõiule kasvavas järjekorras, kasutades funktsiooni sort.Slice() funktsioonis Go.
pakett peamine
importida (
'fmt'
'sorteeri'
)
func peamine () {
n := [] int { 9 , 7 , 3 , 5 }
alustada := 0
lõpp := 3
sorteerida . Viil ( n [ alustada : lõpp ], func ( i , j int ) bool {
tagasi n [ alustada + i ] < n [ alustada + j ]
})
fmt . Println ( n )
}
Algselt loome 'n' lõigu väärtustega [9, 7, 3, 5]. Lisaks on kaks muutujat, 'algus' ja 'lõpp', seatud vastavalt väärtusele 0 ja 3. Need muutujad määravad järjestatava n-lõigu indeksite vahemiku. Seejärel kutsutakse välja funktsioon 'sort.Slice()', mille esimese argumendina on alamlõik 'n[algus:lõpp]'. See alamlõik sisaldab 'n' elemente määratud vahemikus. Pärast seda antakse funktsiooni sort.Slice() sees teise argumendina sortimisfunktsioon.
Siin saab see funktsioon kaks indeksit 'i' ja 'j', mis tähistavad alamlõigu elemente. Alamlõigu elementide võrdlemiseks pääseb sortimisfunktsioon algse lõigu vastavatele elementidele, kasutades algust. See võrdleb n[start+i] ja n[start+j]. Järgmisena kasutab funktsioon sort.Slice() kaasasolevat sortimisfunktsiooni alamlõigu elementide ümberpaigutamiseks kasvavas järjekorras.
Järgmine väljund kuvab, et määratud vahemikus (algusest lõpuni-1) olevad elemendid on sorteeritud ja vahemikust väljapoole jäävad elemendid jäävad muutumatuks.
Näide 3: Golangi sortimise täisarvuline viil, kasutades funktsiooni Sort.Ints()
Lisaks on täisarvude viilude sortimiseks kõige mugavam funktsioon sort.Ints(), ilma et oleks vaja kohandatud sortimismeetodeid rakendada. See toimib otse täisarvulistel lõikudel ja teostab kohapealset sortimist. Järgmine programm sorteerib määratud täisarvud:
pakett peamineimportida (
'fmt'
'sorteeri'
)
func peamine () {
IntSlice := [] int { 10 , 13 , viisteist , üksteist , 14 , 12 }
fmt . Println ( 'Sortimata viil:' , IntSlice )
sorteerida . Ints ( IntSlice )
fmt . Println ( 'Sorteeritud viil:' , IntSlice )
}
Esiteks deklareerime ja initsialiseerime lõigu 'IntSlice' väärtustega [10, 13, 15, 11, 14, 12], mis esindavad algselt sortimata täisarvude kogumit. Seejärel kutsutakse välja funktsioon sort.Ints() koos lõiguga 'IntSlice' kui argumendina 'IntSlice' sortimiseks. Funktsioon sort.Ints() sorteerib sel juhul sisemiselt iga lõigu osa vastavalt optimeeritud sortimisalgoritmile. See muudab algset lõiku otse, paigutades selle elemendid ümber sorteeritud järjekorda.
Järgmine väljund näitab kõigepealt, et kõigepealt kuvatakse sortimata viil, seejärel sorteeritud viil:
Näide 4: Golangi sortimisstringi viil
Go pakub ka sortimispaketi funktsiooni sort.Strings(), mida kasutatakse stringide viilu kindlas järjekorras sortimiseks. Siin aitab stringide viilu sorteerida järgmine programm:
pakett peamineimportida (
'fmt'
'sorteeri'
)
func peamine () {
strSl := [] string { 'golan' , 'püüton' , 'java' , 'perl' , 'masinakiri' }
sorteerida . Stringid ( strSl )
fmt . Println ( strSl )
}
Esmalt lõime strSl-lõigu ['golang', 'python', 'java', 'perl', 'typescript'] väärtustega, mida ei sorteerita. Pärast seda sorteerime lõigu strSl funktsiooniga sort.Strings(), mis sorteerib lõigu elemendid leksikograafilises järjekorras. See funktsioon muudab algset lõiku otse, korraldades selle elemendid nende ASCII väärtuste alusel sorteeritud järjekorda.
Väljund sorteerib stringilõigu kasvavalt, nagu on näidatud järgmiselt:
Näide 5: Golang Check Sort Slice funktsiooni IntAreSort() abil
Go funktsiooni sort.IntsAreSorted() abil saame aga kontrollida, kas antud täisarvude osa on järjestatud kasvavas järjekorras või mitte. Vaatleme järgmist funktsiooni IntAreSort() näidisprogrammi antud lõigu jaoks:
pakett peamineimportida (
'fmt'
'sorteeri'
)
func peamine () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Viilud:' )
fmt . Println ( 'Sortimata viil:' , sl )
tulemus := sorteerida . IntsAreSorted ( sl )
fmt . Println ( ' \n Tulemus:' )
fmt . Println ( 'Kas antud viil on sorteeritud?:' , tulemus )
}
Esiteks on juhuslike täisarvude sortimata osa defineeritud kui 'sl'. See osa sisaldab täisarvude kogumit, mis ei ole kindlas järjekorras. Järgmisena kutsume välja funktsiooni sort.IntsAreSorted() ja edastame argumendina lõigu 'sl'. See funktsioon annab Boole'i tulemuse, mis näitab, kas lõigu sisend on järjestatud kasvavas järjekorras või mitte. Seejärel prindib funktsioon fmt.Println() tulemused, mis väljastab, kas antud lõik on sorditud või mitte, tagastatud Boole'i väärtuse alusel.
Väljund kuvab täisarvude lõigu sortimisjärjestuse jaoks vale, kuna see on sorteerimata:
Näide 6: Golangi vastupidises sortimise viil
Lisaks saame Go sortimispaketi funktsioonide sortReverse() ja sortStringSlice() abil järjestada stringilõike tagurpidi. Järgmine programm demonstreerib funktsiooni sort.Reverse() tööd:
pakett peamineimportida (
'fmt'
'sorteeri'
)
func peamine () {
vokaalLõik := [] string { 'See on' , 'a' , 'mina' , 'sisse' , 'O' }
fmt . Println ( 'Enne sorteerimist:' , vokaalLõik )
sorteerida . Sorteeri ( sorteerida . Tagurpidi ( sorteerida . StringSlice ( vokaalLõik )))
fmt . Println ( 'Pärast sortimist:' , vokaalLõik )
}
Alustuseks määratleme lõigu 'vowelSlice' stringist, mis sisaldab täishäälikuid 'e', 'a', 'i', 'u' ja 'o'. Määratud stringilõigu esialgne sisu prinditakse esmalt funktsiooni “print” abil. Järgmiseks sooritatakse sorteerimisoperatsioon, kasutades argumentidena funktsioone sort.Sort() koos funktsioonidega sort.Reverse() ja sort.StringSlice(). Siin loob 'sort.Reverse()' uue tüübi, mis muudab elementide järjekorra vastupidiseks. Selle argumendiks on tüüp 'sort.StringSlice', mis teisendab vowelSlice'i sorteeritavaks tüübiks.
Siin kuvatakse vokaalid vastupidises tähestikulises järjekorras:
Järeldus
Süvenesime erinevatesse sortimisfunktsioonidesse näidetega, mis sorteerivad etteantud viilu. Samuti käsitlesime alamlõikude sorteerimist ja kontrollimist, kas viil on juba sorteeritud. Seega saame kasutada sortimispaketi võimalusi, et tulla toime paljude sorteerimisprobleemidega nende Go projektides.