Exempel på golangsortering

Exempel Pa Golangsortering



Sortering är en grundläggande programmeringsoperation som inkluderar att placera elementen i en viss ordning. Sorteringspaketet, som Gos officiella bibliotek gör tillgängligt, innehåller flera funktioner för att snabbt sortera skivorna. Att sortera skivor är en vanlig uppgift i många applikationer, från att organisera data för presentation till att optimera sökalgoritmerna. Den här artikeln utforskar de olika sorteringsteknikerna och visar hur de används i Go med hjälp av sorteringspaketet.

Exempel 1: Golang Sortera segment i stigande ordning

Funktionen 'sort.Slice()' är den främsta funktionen i Go som ordnar om elementen i segmentet i stigande eller fallande ordning. Ta hänsyn till följande illustration där skivan är arrangerad i stigande ordning:

paket huvud
importera (
'fmt'
'sortera'
)
func huvud () {
jämn Skiva := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Osorterad skiva:' , jämn Skiva )
sortera . Skiva ( jämn Skiva , func ( i , j int ) bool {
lämna tillbaka jämn Skiva [ i ] < evenSlice [ j ]
})
fmt . Println ( 'Sorterad skiva:' , jämn Skiva )
}

I början av main()-funktionen definierar vi segmentet evenSlice med värdena {10, 2, 8, 4, 0, 6}. Denna del representerar en samling jämna tal som initialt är osorterade. För att sortera segmentet evenSlice används funktionen sort.Slice() med segmentet. Inuti sort.Slice()-funktionen tillhandahålls en sorteringsfunktion som ett argument. Denna funktion bestämmer sorteringsordningen genom att jämföra skivans två element vid 'i'- och 'j'-index. Om evenSlice[i] är mindre än evenSlice[j], returnerar det sant; annars returnerar det falskt. Funktionen sort.Slice() använder den här jämförelsefunktionen för att ordna om elementen i segmentet 'evenSlice' i stigande ordning.







Resultaten av det sorterade segmentet i stigande ordning genereras i följande utdataskärm:





Exempel 2: Golang sorteringsdelskiva

Därefter tillämpas sorteringen på underdelen av den angivna delen i stigande ordning med funktionen sort.Slice() i Go.





paket huvud
importera (
'fmt'
'sortera'
)
func huvud () {
n := [] int { 9 , 7 , 3 , 5 }
Start := 0
slutet := 3
sortera . Skiva ( n [ Start : slutet ], func ( i , j int ) bool {
lämna tillbaka n [ Start + i ] < n [ Start + j ]
})
fmt . Println ( n )
}

Till att börja med skapar vi 'n'-delen med värdena [9, 7, 3, 5]. Dessutom är två variabler, 'start' och 'slut', satta till 0 respektive 3. Dessa variabler definierar intervallet av index i 'n'-delen som kommer att sorteras. Funktionen “sort.Slice()” anropas sedan med underdelen “n[start:slut]” som första argument. Den här underdelen innehåller elementen av 'n' inom det angivna intervallet. Därefter ges en sorteringsfunktion som det andra argumentet i sort.Slice()-funktionen.

Här får den funktionen två index, 'i' och 'j', som representerar elementen i delsegmentet. För att jämföra elementen inom delsegmentet kommer sorteringsfunktionen åt motsvarande element i det ursprungliga segmentet med start offset. Den jämför n[start+i] och n[start+j]. Därefter använder sort.Slice()-funktionen den medföljande sorteringsfunktionen för att ordna om elementen inom underdelen i stigande ordning.



Följande utdata visar att elementen inom det angivna intervallet (start till slut-1) är sorterade, och elementen utanför intervallet förblir oförändrade:

Exempel 3: Golang Sortera heltalssegment med funktionen Sort.Ints()

Dessutom är det mest bekväma att sortera segmenten av heltal funktionen sort.Ints() utan att behöva implementera de anpassade sorteringsmetoderna. Den verkar direkt på heltalsskivor och utför en sortering på plats. Följande program sorterar de angivna heltal:

paket huvud
importera (
'fmt'
'sortera'
)
func huvud () {
IntSlice := [] int { 10 , 13 , femton , elva , 14 , 12 }
fmt . Println ( 'Osorterad skiva:' , IntSlice )
sortera . Ints ( IntSlice )
fmt . Println ( 'Sorterad skiva:' , IntSlice )
}

Först deklarerar och initierar vi 'IntSlice'-delen med [10, 13, 15, 11, 14, 12] värden som representerar en samling heltal som initialt är osorterade. Sedan anropas sort.Ints()-funktionen med 'IntSlice'-delen som ett argument för att sortera 'IntSlice'. Funktionen sort.Ints() i detta fall sorterar internt varje del av segmentet enligt en optimerad sorteringsalgoritm. Den modifierar den ursprungliga skivan direkt och ordnar om dess element i en sorterad ordning.

Följande utdata visar först att det osorterade segmentet visas först, följt av det sorterade segmentet:

Exempel 4: Golang Sort String Slice

Go erbjuder också sort.Strings()-funktionen för sortpaketet som används för att sortera en del av strängar i en specifik ordning. Här hjälper följande program till att sortera strängen:

paket huvud
importera (
'fmt'
'sortera'
)
func huvud () {
strSl := [] sträng { 'golan' , 'pytonorm' , 'java' , 'perl' , 'Maskinskrift' }
sortera . Strängar ( strSl )
fmt . Println ( strSl )
}

Vi etablerade först 'strSl'-delen med värdena ['golang', 'python', 'java', 'perl', 'typescript'] som inte är sorterade. Efter det sorterar vi 'strSl'-delen med sort.Strings()-funktionen som sorterar elementen i segmentet i lexikografisk ordning. Den här funktionen modifierar det ursprungliga segmentet direkt och ordnar om dess element i sorterad ordning baserat på deras ASCII-värden.

Utdata sorterar strängskivan på ett stigande sätt som visas i följande:

Exempel 5: Golang Check Sort Slice med IntAreSort()-funktionen

Men med funktionen sort.IntsAreSorted() i Go kan vi kontrollera om en given del av heltal är sorterad i stigande ordning eller inte. Betrakta följande exempelprogram för funktionen IntAreSort() för den givna delen:

paket huvud
importera (
'fmt'
'sortera'
)
func huvud () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Skivor:' )
fmt . Println ( 'Osorterad skiva: ' , sl )
resultat := sortera . IntsAreSorted ( sl )
fmt . Println ( ' \n Resultat:' )
fmt . Println ( 'Är given Slice sorterad?: ' , resultat )
}

Först definieras en osorterad del av slumpmässiga heltal som 'sl'. Denna del innehåller en samling heltal i ingen speciell ordning. Därefter anropar vi sort.IntsAreSorted()-funktionen och skickar 'sl'-delen som ett argument. Den här funktionen ger ett booleskt resultat som indikerar om segmentinmatningen är ordnad i stigande ordning eller inte. Sedan skriver funktionen fmt.Println() ut resultaten som matar ut om det givna segmentet är sorterat eller inte baserat på det returnerade booleska värdet.

Utdatat visar falskt för sorteringsordningen för en del av heltal eftersom den är osorterad:

Exempel 6: Golang omvänd sorteringsskiva

Vidare, genom att använda funktionerna sortReverse() och sortStringSlice() från sorteringspaketet i Go, kan vi omvändsortera en del av strängar. Följande program visar hur sort.Reverse() fungerar:

paket huvud
importera (
'fmt'
'sortera'
)
func huvud () {
vokalskiva := [] sträng { 'Det är' , 'a' , 'jag' , 'i' , 'O' }
fmt . Println ( 'Innan du sorterar :' , vokalskiva )
sortera . Sortera ( sortera . Omvänd ( sortera . StringSlice ( vokalskiva )))
fmt . Println ( 'Efter  sortering :' , vokalskiva )
}

Vi börjar med att definiera en del av 'vowelSlice'-strängen som innehåller vokalerna 'e', 'a', 'i', 'u' och 'o'. Det initiala innehållet i den angivna delen av strängar skrivs först ut med 'skriv ut'-funktionen. Därefter utförs sorteringsoperationen med hjälp av sort.Sort()-funktionen med sort.Reverse() och sort.StringSlice()-funktionerna som argument. Här skapar 'sort.Reverse()' en ny typ som vänder ordningen på elementen. Den tar typen 'sort.StringSlice' som argument som konverterar vokalSlice till en sorterbar typ.

Utdata här visar vokalerna i omvänd alfabetisk ordning:

Slutsats

Vi fördjupade oss i olika sorteringsfunktioner med exempel som sorterar den medföljande skivan. Vi behandlade också om sortering av underskivor och att kontrollera om en skiva redan är sorterad. Därför kan vi utnyttja sorteringspaketets kapacitet för att tackla ett brett utbud av sorteringsutmaningar i deras Go-projekt.