Eksempler på Golang-sortering

Eksempler Pa Golang Sortering



Sortering er en grunnleggende programmeringsoperasjon som inkluderer å sette elementene i en bestemt rekkefølge. Sorteringspakken, som Gos offisielle bibliotek gjør tilgjengelig, inkluderer flere funksjoner for raskt å sortere skivene. Sortering av skiver er en vanlig oppgave i mange applikasjoner, fra å organisere dataene for presentasjon til å optimalisere søkealgoritmene. Denne artikkelen utforsker de forskjellige sorteringsteknikkene og demonstrerer bruken av dem i Go ved å bruke sorteringspakken.

Eksempel 1: Golang sorteringsseksjon i stigende rekkefølge

Funksjonen 'sort.Slice()' er den fremste funksjonen i Go som omorganiserer elementene i skiven i stigende eller synkende rekkefølge. Ta hensyn til følgende illustrasjon der skiven er arrangert i stigende rekkefølge:

pakke hoved-
import (
'fmt'
'sortere'
)
func hoved- () {
jevn Slice := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Usortert skive:' , jevn Slice )
sortere . Skive ( jevn Slice , func ( Jeg , j int ) bool {
komme tilbake jevn Slice [ Jeg ] < evenSlice [ j ]
})
fmt . Println ( 'Sortert skive:' , jevn Slice )
}

I begynnelsen av main()-funksjonen definerer vi evenSlice-skiven med {10, 2, 8, 4, 0, 6}-verdier. Denne delen representerer en samling partall som i utgangspunktet er usortert. For å sortere evenSlice-skiven, brukes sort.Slice()-funksjonen med skiven. Inne i sort.Slice()-funksjonen er en sorteringsfunksjon gitt som et argument. Denne funksjonen bestemmer sorteringsrekkefølgen ved å sammenligne skivens to elementer ved 'i' og 'j'-indekser. Hvis evenSlice[i] er mindre enn evenSlice[j], returnerer det sant; ellers returnerer den falsk. Sort.Slice()-funksjonen bruker denne sammenligningsfunksjonen til å omorganisere elementene i 'evenSlice'-stykket i stigende rekkefølge.







Resultatene av den sorterte skiven i stigende rekkefølge genereres i følgende utdataskjerm:





Eksempel 2: Golang sorteringsdelskive

Deretter brukes sorteringen på underdelen av den angitte delen i stigende rekkefølge ved å bruke sort.Slice()-funksjonen i Go.





pakke hoved-
import (
'fmt'
'sortere'
)
func hoved- () {
n := [] int { 9 , 7 , 3 , 5 }
start := 0
slutt := 3
sortere . Skive ( n [ start : slutt ], func ( Jeg , j int ) bool {
komme tilbake n [ start + Jeg ] < n [ start + j ]
})
fmt . Println ( n )
}

Til å begynne med lager vi 'n'-stykket med [9, 7, 3, 5] verdiene. I tillegg er to variabler, 'start' og 'slutt', satt til henholdsvis 0 og 3. Disse variablene definerer rekkevidden av indekser i 'n'-stykket som skal sorteres. Funksjonen 'sort.Slice()' kalles deretter med understykket 'n[start:slutt]' som det første argumentet. Denne underdelen inneholder elementene til 'n' innenfor det angitte området. Etter det gis en sorteringsfunksjon som det andre argumentet i sort.Slice()-funksjonen.

Her mottar denne funksjonen to indekser, «i» og «j», som representerer elementene i understykket. For å sammenligne elementene i understykket, får sorteringsfunksjonen tilgang til de tilsvarende elementene i den opprinnelige stykket ved å bruke starten offset. Den sammenligner n[start+i] og n[start+j]. Deretter bruker sort.Slice()-funksjonen den medfølgende sorteringsfunksjonen til å omorganisere elementene i underdelen i stigende rekkefølge.



Følgende utdata viser at elementene innenfor det angitte området (start til slutt-1) er sortert, og elementene utenfor området forblir uendret:

Eksempel 3: Golang-sortering av heltallssnitt ved å bruke Sort.Ints()-funksjonen

Dessuten er den mest praktiske å sortere skivene av heltall sort.Ints()-funksjonen uten behov for å implementere de tilpassede sorteringsmetodene. Den virker direkte på heltallsskiver og utfører en på stedet sortering. Følgende program sorterer de angitte heltallene:

pakke hoved-
import (
'fmt'
'sortere'
)
func hoved- () {
IntSlice := [] int { 10 , 1. 3 , femten , elleve , 14 , 12 }
fmt . Println ( 'Usortert skive:' , IntSlice )
sortere . Ints ( IntSlice )
fmt . Println ( 'Sortert skive:' , IntSlice )
}

Først deklarerer og initialiserer vi 'IntSlice'-stykket med [10, 13, 15, 11, 14, 12] verdiene som representerer en samling heltall som i utgangspunktet er usortert. Deretter kalles sort.Ints()-funksjonen med 'IntSlice'-stykket som et argument for å sortere 'IntSlice'. Sort.Ints()-funksjonen i dette tilfellet sorterer internt hver del av snittet i henhold til en optimalisert sorteringsalgoritme. Den modifiserer den originale skiven direkte, og omorganiserer elementene i en sortert rekkefølge.

Følgende utdata viser først at den usorterte skiven vises først, etterfulgt av den sorterte skiven:

Eksempel 4: Golang Sort String Slice

Go tilbyr også sort.Strings()-funksjonen til sorteringspakken som brukes til å sortere et stykke strenger i en bestemt rekkefølge. Her hjelper følgende program med å sortere stykket av strenger:

pakke hoved-
import (
'fmt'
'sortere'
)
func hoved- () {
strSl := [] streng { 'golan' , 'pyton' , 'java' , 'perl' , 'typeskrift' }
sortere . Strenger ( strSl )
fmt . Println ( strSl )
}

Vi etablerte først 'strSl'-stykket med verdiene ['golang', 'python', 'java', 'perl', 'typescript'] som ikke er sortert. Etter det sorterer vi 'strSl'-stykket med sort.Strings()-funksjonen som sorterer elementene i skiven i leksikografisk rekkefølge. Denne funksjonen endrer den opprinnelige skiven direkte, og omorganiserer elementene i sortert rekkefølge basert på deres ASCII-verdier.

Utgangen sorterer strengskiven på stigende måte som vist i følgende:

Eksempel 5: Golang Check Sort Slice ved å bruke IntAreSort()-funksjonen

Men med sort.IntsAreSorted()-funksjonen til Go, kan vi sjekke om en gitt del av heltall er sortert i stigende rekkefølge eller ikke. Tenk på følgende eksempelprogram for IntAreSort()-funksjonen for den gitte delen:

pakke hoved-
import (
'fmt'
'sortere'
)
func hoved- () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Skiver:' )
fmt . Println ( 'Usortert skive: ' , sl )
resultat := sortere . IntsAreSorted ( sl )
fmt . Println ( ' \n Resultat:' )
fmt . Println ( 'Er gitt Slice sortert?: ' , resultat )
}

For det første er en usortert del av tilfeldige heltall definert som 'sl'. Denne delen inneholder en samling av heltall i ingen spesiell rekkefølge. Deretter kaller vi sort.IntsAreSorted()-funksjonen og sender 'sl'-delen som et argument. Denne funksjonen gir et boolsk resultat som indikerer hvorvidt snittinndata er ordnet i stigende rekkefølge. Deretter skriver fmt.Println()-funksjonen ut resultatene som gir ut om den gitte delen er sortert eller ikke basert på den returnerte boolske verdien.

Utdataene viser usort for sorteringsrekkefølgen til en del av heltall ettersom den er usortert:

Eksempel 6: Golang omvendt sorteringsskive

Videre, ved å bruke sortReverse()- og sortStringSlice()-funksjonene fra sorteringspakken i Go, kan vi omvendt-sortere en del av strenger. Følgende program viser hvordan sort.Reverse()-funksjonen fungerer:

pakke hoved-
import (
'fmt'
'sortere'
)
func hoved- () {
vokalSkive := [] streng { 'Det er' , 'en' , 'Jeg' , 'i' , 'O' }
fmt . Println ( 'Før sortering:' , vokalSkive )
sortere . Sortere ( sortere . Omvendt ( sortere . StringSlice ( vokalSkive )))
fmt . Println ( 'Etter  sortering :' , vokalSkive )
}

Vi begynner med å definere en del av 'vowelSlice'-strengen som inneholder vokalene 'e', 'a', 'i', 'u' og 'o'. Det opprinnelige innholdet i den angitte delen av strenger skrives ut først ved å bruke 'print'-funksjonen. Deretter utføres sorteringsoperasjonen ved å bruke sort.Sort()-funksjonen med sort.Reverse() og sort.StringSlice()-funksjonene som argumenter. Her oppretter 'sort.Reverse()' en ny type som reverserer rekkefølgen på elementene. Den tar typen 'sort.StringSlice' som argument som konverterer vokalSlice til en sorterbar type.

Utgangen her viser vokalene i omvendt alfabetisk rekkefølge:

Konklusjon

Vi fordypet oss i ulike sorteringsfunksjoner med eksempler som sorterer den angitte skiven. Vi dekket også om sortering av underskiver og sjekk om en skive allerede er sortert. Derfor kan vi utnytte sorteringspakkens evner til å takle et bredt spekter av sorteringsutfordringer i deres Go-prosjekter.