1. példa: Golang rendezési szelet növekvő sorrendben
A „sort.Slice()” függvény a Go legelső funkciója, amely a szelet elemeit növekvő vagy csökkenő sorrendbe rendezi át. Vegye figyelembe az alábbi ábrát, ahol a szelet növekvő sorrendben van elrendezve:
csomag fő-import (
'fmt'
'fajta'
)
func fő- () {
egyenletes Szelet := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Rendezett szelet:' , egyenletes Szelet )
fajta . Szelet ( egyenletes Szelet , func ( én , j int ) bool {
Visszatérés egyenletes Szelet [ én ] < evenSlice [ j ]
})
fmt . Println ( 'Sorted slice:' , egyenletes Szelet )
}
A main() függvény elején definiáljuk az evenSlice szeletet a {10, 2, 8, 4, 0, 6} értékekkel. Ez a szelet kezdetben rendezetlen páros számok gyűjteményét képviseli. A evenSlice szelet rendezéséhez a sort.Slice() függvényt alkalmazzuk a szelettel. A sort.Slice() függvényen belül argumentumként szerepel egy rendezési függvény. Ez a függvény a szelet két elemének „i” és „j” indexnél történő összehasonlításával határozza meg a rendezési sorrendet. Ha a páros szelet[i] kisebb, mint a páros szelet[j], akkor igazat ad vissza; ellenkező esetben hamis értéket ad vissza. A sort.Slice() függvény ezt az összehasonlító függvényt használja az „evenSlice” szelet elemeinek növekvő sorrendbe rendezésére.
A növekvő sorrendben rendezett szelet eredményei a következő kimeneti képernyőn generálódnak:
2. példa: Golang rendezési alkatrészszelet
Ezután a rendezést a megadott szelet alszeletére alkalmazzuk növekvő sorrendben a Go sort.Slice() függvényével.
csomag fő-
import (
'fmt'
'fajta'
)
func fő- () {
n := [] int { 9 , 7 , 3 , 5 }
Rajt := 0
vége := 3
fajta . Szelet ( n [ Rajt : vége ], func ( én , j int ) bool {
Visszatérés n [ Rajt + én ] < n [ Rajt + j ]
})
fmt . Println ( n )
}
Kezdetben létrehozzuk az „n” szeletet a [9, 7, 3, 5] értékekkel. Ezenkívül két változó, a „start” és „end” 0-ra, illetve 3-ra van állítva. Ezek a változók határozzák meg az indexek tartományát az „n” szeletben, amelyet rendezni fog. Ezután a „sort.Slice()” függvény meghívása az „n[start:end]” alszelettel az első argumentum. Ez az alszelet az „n” elemeit tartalmazza a megadott tartományon belül. Ezt követően a sort.Slice() függvényen belül második argumentumként egy rendezési függvény kerül megadásra.
Itt a függvény két indexet kap, az „i”-t és a „j-t”, amelyek az alszeleten belüli elemeket reprezentálják. Az alszeleten belüli elemek összehasonlításához a rendezési funkció az eredeti szelet megfelelő elemeit a start segítségével éri el. Összehasonlítja az n[start+i]-t és az n[start+j]-t. Ezután a sort.Slice() függvény a megadott rendezési függvényt használja az alszeleten belüli elemek növekvő sorrendbe rendezésére.
A következő kimenet azt mutatja, hogy a megadott tartományon belüli elemek (kezdettől-1-ig) rendezve vannak, és a tartományon kívüli elemek változatlanok maradnak:
3. példa: Golang Integer Slice rendezése a Sort.Ints() függvény segítségével
Ezenkívül az egész számokból álló szeleteket a legkényelmesebb a sort.Ints() függvény rendezni anélkül, hogy szükség lenne az egyéni rendezési módszerek megvalósítására. Közvetlenül az egész szeletekre hat, és helyben történő rendezést hajt végre. A következő program rendezi a megadott egész számokat:
csomag fő-import (
'fmt'
'fajta'
)
func fő- () {
IntSlice := [] int { 10 , 13 , tizenöt , tizenegy , 14 , 12 }
fmt . Println ( 'Rendezett szelet:' , IntSlice )
fajta . Ints ( IntSlice )
fmt . Println ( 'Sorted slice:' , IntSlice )
}
Először deklaráljuk és inicializáljuk az „IntSlice” szeletet a [10, 13, 15, 11, 14, 12] értékekkel, amelyek kezdetben rendezetlen egész számok gyűjteményét jelentik. Ezután a sort.Ints() függvény meghívásra kerül az „IntSlice” szelettel, mint argumentumként az „IntSlice” rendezésére. A sort.Ints() függvény ebben az esetben belsőleg rendezi a szelet minden részét egy optimalizált rendezési algoritmus szerint. Közvetlenül módosítja az eredeti szeletet, elemeit rendezett sorrendbe rendezve.
A következő kimenet először azt mutatja, hogy először a rendezetlen szelet jelenik meg, majd a rendezett szelet:
4. példa: Golang Sort String Slice
A Go a rendezési csomag sort.Strings() függvényét is kínálja, amely a karakterláncok egy szeletének meghatározott sorrendben történő rendezésére szolgál. Itt a következő program segít a karakterláncok szeletének rendezésében:
csomag fő-import (
'fmt'
'fajta'
)
func fő- () {
strSl := [] húr { 'golan' , 'piton' , 'Jáva' , 'perl' , 'gépelt' }
fajta . Húrok ( strSl )
fmt . Println ( strSl )
}
Először létrehoztuk az „strSl” szeletet a ['golang', 'python', 'java', 'perl', 'typescript'] értékekkel, amelyek nincsenek rendezve. Ezután az „strSl” szeletet a sort.Strings() függvénnyel rendezzük, amely lexikográfiai sorrendbe rendezi a szelet elemeit. Ez a funkció közvetlenül módosítja az eredeti szeletet, átrendezi elemeit rendezett sorrendbe az ASCII-értékeik alapján.
A kimenet növekvő sorrendbe rendezi a karakterlánc szeletet, ahogy az a következőképpen jelenik meg:
5. példa: Golang-ellenőrző rendezési szelet az IntAreSort() függvény használatával
A Go sort.IntsAreSorted() függvényével azonban ellenőrizhetjük, hogy az egész számok adott szelete növekvő sorrendben van-e rendezve vagy sem. Tekintsük az IntAreSort() függvény alábbi példaprogramját az adott szelethez:
csomag fő-import (
'fmt'
'fajta'
)
func fő- () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Szeletek:' )
fmt . Println ( 'Rendezés nélküli szelet:' , sl )
eredmény := fajta . IntsAreSorted ( sl )
fmt . Println ( ' \n Eredmény:' )
fmt . Println ( 'Válogatva van az adott szelet?:' , eredmény )
}
Először is, a véletlenszerű egész számok rendezetlen szeletét „sl”-ként határozzuk meg. Ez a szelet egész számokat tartalmaz nem meghatározott sorrendben. Ezután meghívjuk a sort.IntsAreSorted() függvényt, és argumentumként átadjuk az „sl” szeletet. Ez a függvény logikai eredményt ad, amely jelzi, hogy a szelet bemenet növekvő sorrendben van-e elrendezve. Ezután az fmt.Println() függvény kiírja az eredményeket, amely kiírja, hogy az adott szelet a visszaadott logikai érték alapján rendezve van-e vagy sem.
A kimenet hamis értéket jelenít meg egy egész számok szeletének rendezési sorrendjében, mivel nincs rendezve:
6. példa: Golang fordított rendezési szelet
Továbbá a Go rendezési csomagjából származó sortReverse() és sortStringSlice() függvények segítségével fordított sorrendben rendezhetjük a karakterláncok egy szeletét. A következő program a sort.Reverse() függvény működését mutatja be:
csomag fő-import (
'fmt'
'fajta'
)
func fő- () {
magánhangzóSzelet := [] húr { 'Ez' , 'a' , 'én' , 'ban ben' , 'O' }
fmt . Println ( 'Rendezés előtt:' , magánhangzóSzelet )
fajta . Fajta ( fajta . Fordított ( fajta . StringSlice ( magánhangzóSzelet )))
fmt . Println ( 'Rendezés után:' , magánhangzóSzelet )
}
Kezdjük azzal, hogy meghatározzuk a „vowelSlice” karakterlánc egy szeletét, amely az „e”, „a”, „i”, „u” és „o” magánhangzókat tartalmazza. A megadott karakterláncszelet kezdeti tartalma kerül kinyomtatásra először a „print” funkció segítségével. Ezután a rendezési műveletet a sort.Sort() függvény segítségével hajtjuk végre, argumentumként a sort.Reverse() és sort.StringSlice() függvényekkel. Itt a „sort.Reverse()” egy új típust hoz létre, amely megfordítja az elemek sorrendjét. A „sort.StringSlice” típust veszi argumentumként, amely a vowelSlice-t rendezhető típussá alakítja.
Az itt megjelenő kimenet fordított ábécé sorrendben jeleníti meg a magánhangzókat:
Következtetés
Különböző rendezési funkciókban elmélyültünk példákkal, amelyek a megadott szeletet rendezik. Kitértünk az alszeletek rendezéséről és annak ellenőrzéséről is, hogy egy szelet már rendezve van-e. Így kihasználhatjuk a rendezési csomag képességeit, hogy a Go projektjeik során a rendezési kihívások széles skáláját kezeljük.