1. piemērs: Golanga kārtošanas šķēle augošā secībā
Funkcija “sort.Slice()” ir Go galvenā funkcija, kas pārkārto slāņa elementus augošā vai dilstošā secībā. Ņemiet vērā šādu ilustrāciju, kur šķēle ir sakārtota augošā secībā:
iepakojums galvenaisimports (
'fmt'
'šķirot'
)
func galvenais () {
patŠķēle := [] starpt { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Nešķirota šķēle:' , patŠķēle )
kārtot . Šķēle ( patŠķēle , func ( i , j starpt ) bool {
atgriezties patŠķēle [ i ] < patŠķēle [ j ]
})
fmt . Println ( 'Sorted slice:' , patŠķēle )
}
Funkcijas main() sākumā mēs definējam EvenSlice šķēli ar vērtībām {10, 2, 8, 4, 0, 6}. Šī sadaļa attēlo pāra skaitļu kopumu, kas sākotnēji ir nešķiroti. Lai kārtotu patSlice šķēli, ar šo šķēli tiek izmantota funkcija sort.Slice(). Funkcijā sort.Slice() kā arguments tiek nodrošināta kārtošanas funkcija. Šī funkcija nosaka kārtošanas secību, salīdzinot divus slāņa elementus pēc “i” un “j” indeksiem. Ja evenSlice[i] ir mazāks par evenSlice[j], tas atgriež true; pretējā gadījumā tas atgriež nepatiesu. Funkcija sort.Slice() izmanto šo salīdzināšanas funkciju, lai pārkārtotu slāņa “evenSlice” elementus augošā secībā.
Šķirotās daļas rezultāti augošā secībā tiek ģenerēti šādā izvades ekrānā:
2. piemērs: Golangas kārtošanas daļas šķēle
Pēc tam kārtošana tiek lietota norādītā slāņa apakšskalei augošā secībā, izmantojot funkciju sort.Slice() programmā Go.
iepakojums galvenais
imports (
'fmt'
'šķirot'
)
func galvenais () {
n := [] starpt { 9 , 7 , 3 , 5 }
sākt := 0
beigas := 3
kārtot . Šķēle ( n [ sākt : beigas ], func ( i , j starpt ) bool {
atgriezties n [ sākt + i ] < n [ sākt + j ]
})
fmt . Println ( n )
}
Sākotnēji mēs izveidojam “n” šķēli ar vērtībām [9, 7, 3, 5]. Turklāt divi mainīgie, “sākums” un “beigas”, ir iestatīti attiecīgi uz 0 un 3. Šie mainīgie definē indeksu diapazonu “n” daļā, kas tiks sakārtots. Pēc tam tiek izsaukta funkcija “sort.Slice()” ar apakšskali “n[sākums:beigas]” kā pirmo argumentu. Šajā apakšskalā ir “n” elementi norādītajā diapazonā. Pēc tam kā otrais arguments funkcijā sort.Slice() tiek norādīta kārtošanas funkcija.
Šeit šī funkcija saņem divus indeksus 'i' un 'j', kas attēlo elementus apakšslānī. Lai salīdzinātu elementus apakšslānī, kārtošanas funkcija piekļūst atbilstošajiem elementiem sākotnējā sadaļā, izmantojot sākumu. Nobīde. Tā salīdzina n[sākt+i] un n[sākt+j]. Pēc tam funkcija sort.Slice() izmanto nodrošināto kārtošanas funkciju, lai pārkārtotu elementus apakšskilā augošā secībā.
Šī izvade parāda, ka elementi norādītajā diapazonā (no sākuma līdz beigām-1) ir sakārtoti un elementi ārpus diapazona paliek nemainīgi:
3. piemērs: Golang Kārtot Integer Slice, izmantojot funkciju Sort.Ints()
Turklāt visērtākā veselo skaitļu slāņu šķirošanai ir funkcija sort.Ints() bez nepieciešamības ieviest pielāgotas kārtošanas metodes. Tas iedarbojas tieši uz veseliem skaitļiem un veic kārtošanu uz vietas. Šī programma sakārto norādītos veselus skaitļus:
iepakojums galvenaisimports (
'fmt'
'šķirot'
)
func galvenais () {
IntSlice := [] starpt { 10 , 13 , piecpadsmit , vienpadsmit , 14 , 12 }
fmt . Println ( 'Nešķirota šķēle:' , IntSlice )
kārtot . Ints ( IntSlice )
fmt . Println ( 'Sorted slice:' , IntSlice )
}
Pirmkārt, mēs deklarējam un inicializējam “IntSlice” šķēli ar vērtībām [10, 13, 15, 11, 14, 12], kas attēlo veselu skaitļu kopumu, kas sākotnēji nav sakārtoti. Pēc tam funkcija sort.Ints() tiek izsaukta ar 'IntSlice' šķēli kā argumentu, lai kārtotu 'IntSlice'. Funkcija sort.Ints() šajā gadījumā iekšēji kārto katru šķēles daļu saskaņā ar optimizētu kārtošanas algoritmu. Tas tieši modificē sākotnējo šķēli, pārkārtojot tā elementus sakārtotā secībā.
Sekojošā izvade vispirms parāda, ka vispirms tiek parādīts nešķirotais gabals, pēc tam kārtotais posms:
4. piemērs: Golang kārtošanas virknes šķēle
Go piedāvā arī šķirošanas pakotnes funkciju sort.Strings(), ko izmanto, lai kārtotu virkņu daļu noteiktā secībā. Tālāk norādītā programma palīdz sakārtot virkņu daļu:
iepakojums galvenaisimports (
'fmt'
'šķirot'
)
func galvenais () {
strSl := [] virkne { 'golans' , 'pitons' , 'java' , 'perl' , 'mašīnraksts' }
kārtot . Stīgas ( strSl )
fmt . Println ( strSl )
}
Vispirms mēs izveidojām “strSl” šķēli ar [“golang”, “python”, “java”, “perl”, “typescript”] vērtībām, kas nav sakārtotas. Pēc tam mēs sakārtojam “strSl” šķēli ar funkciju sort.Strings(), kas sakārto šķēles elementus leksikogrāfiskā secībā. Šī funkcija tieši maina sākotnējo šķēli, pārkārtojot tā elementus sakārtotā secībā, pamatojoties uz to ASCII vērtībām.
Izvade sakārto virknes šķēli augošā veidā, kā parādīts tālāk:
5. piemērs: Golangas pārbaudes kārtošanas sadaļa, izmantojot funkciju IntAreSort()
Tomēr, izmantojot Go funkciju sort.IntsAreSorted(), mēs varam pārbaudīt, vai dotā veselo skaitļu daļa ir sakārtota augošā secībā. Apsveriet šādu IntAreSort() funkcijas programmas piemēru dotajam šķēlumam:
iepakojums galvenaisimports (
'fmt'
'šķirot'
)
func galvenais () {
sl := [] starpt { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Šķēles:' )
fmt . Println ( 'Nešķirota šķēle:' , sl )
rezultāts := kārtot . IntsAreSorted ( sl )
fmt . Println ( ' \n Rezultāts:' )
fmt . Println ( 'Vai dotā Šķēle ir sakārtota?:' , rezultāts )
}
Pirmkārt, nešķirota nejaušu veselu skaitļu daļa tiek definēta kā “sl”. Šajā sadaļā ir veselu skaitļu kolekcija, kas nav noteikta noteiktā secībā. Tālāk mēs izsaucam funkciju sort.IntsAreSorted() un nododam “sl” slāli kā argumentu. Šī funkcija nodrošina Būla rezultātu, kas norāda, vai šķēluma ievade ir sakārtota augošā secībā. Pēc tam funkcija fmt.Println() izdrukā rezultātus, kas izvada, vai dotā daļa ir sakārtota, pamatojoties uz atgriezto Būla vērtību.
Izvade parāda nepatiesu veselu skaitļu kārtošanas secību, jo tā ir nešķirota:
6. piemērs: Golangas apgrieztās kārtošanas sadaļa
Turklāt, izmantojot funkcijas sortReverse() un sortStringSlice() no kārtošanas pakotnes programmā Go, mēs varam apgrieztā secībā kārtot virkņu daļu. Šī programma parāda funkcijas sort.Reverse() darbību:
iepakojums galvenaisimports (
'fmt'
'šķirot'
)
func galvenais () {
patskaņa Šķēle := [] virkne { 'Tas ir' , 'a' , 'es' , 'iekšā' , 'O' }
fmt . Println ( 'Pirms šķirošanas:' , patskaņa Šķēle )
kārtot . Kārtot ( kārtot . Reverss ( kārtot . StringSlice ( patskaņa Šķēle )))
fmt . Println ( 'Pēc kārtošanas:' , patskaņa Šķēle )
}
Mēs sākam, definējot virknes “vowelSlice” daļu, kas satur patskaņus “e”, “a”, “i”, “u” un “o”. Norādītās virkņu daļas sākotnējais saturs tiek izdrukāts vispirms, izmantojot funkciju “print”. Tālāk tiek veikta kārtošanas darbība, izmantojot funkciju sort.Sort() ar funkcijām sort.Reverse() un sort.StringSlice() kā argumentus. Šeit “sort.Reverse()” izveido jaunu veidu, kas maina elementu secību. Kā arguments tiek izmantots tips “sort.StringSlice”, kas pārvērš patskaņu Slice par šķirojamu tipu.
Izvade šeit parāda patskaņus apgrieztā alfabētiskā secībā:
Secinājums
Iedziļinājāmies dažādās šķirošanas funkcijās ar piemēriem, kas sašķiro paredzēto šķēli. Mēs arī runājām par apakšsķēļu šķirošanu un pārbaudi, vai šķēle jau ir sakārtota. Tādējādi mēs varam izmantot šķirošanas pakotnes iespējas, lai risinātu dažādas šķirošanas problēmas viņu Go projektos.