Halimbawa 1: Golang Sort Slice in Ascending Order
Ang function na 'sort.Slice()' ay ang pangunahing function sa Go na muling nagsasaayos ng mga elemento ng slice sa pataas na ayos o pababang ayos. Isaalang-alang ang sumusunod na paglalarawan kung saan ang hiwa ay nakaayos sa pataas na pagkakasunud-sunod:
pakete pangunahingangkat (
'fmt'
'uri'
)
func pangunahing () {
kahitSlice := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Hindi pinagsunod-sunod na hiwa:' , kahitSlice )
uri . Hiwain ( kahitSlice , func ( i , j int ) bool {
bumalik kahitSlice [ i ] < kahitSlice [ j ]
})
fmt . Println ( 'Inayos na hiwa:' , kahitSlice )
}
Sa simula ng main() function, tinutukoy namin ang evenSlice slice na may mga value na {10, 2, 8, 4, 0, 6}. Ang slice na ito ay kumakatawan sa isang koleksyon ng mga even na numero na sa una ay hindi naayos. Upang pag-uri-uriin ang evenSlice slice, ang sort.Slice() function ay ginagamit sa slice. Sa loob ng function na sort.Slice(), isang function ng pag-uuri ay ibinigay bilang isang argumento. Tinutukoy ng function na ito ang pagkakasunud-sunod ng pag-uuri sa pamamagitan ng paghahambing ng dalawang elemento ng slice sa mga indeks ng “i” at “j”. Kung ang evenSlice[i] ay mas mababa sa evenSlice[j], ito ay nagbabalik ng true; kung hindi, ito ay nagbabalik ng false. Ang sort.Slice() function ay gumagamit ng paghahambing na function na ito upang muling ayusin ang mga elemento ng 'evenSlice' slice sa pataas na pagkakasunud-sunod.
Ang mga resulta ng pinagsunod-sunod na slice sa pataas na pagkakasunud-sunod ay nabuo sa sumusunod na screen ng output:
Halimbawa 2: Golang Sort Part Slice
Susunod, inilalapat ang pag-uuri sa sub-slice ng tinukoy na slice sa pataas na pagkakasunod-sunod gamit ang sort.Slice() function sa Go.
pakete pangunahing
angkat (
'fmt'
'uri'
)
func pangunahing () {
n := [] int { 9 , 7 , 3 , 5 }
simulan := 0
wakas := 3
uri . Hiwain ( n [ simulan : wakas ], func ( i , j int ) bool {
bumalik n [ simulan + i ] < n [ simulan + j ]
})
fmt . Println ( n )
}
Sa una, ginagawa namin ang 'n' slice na may mga [9, 7, 3, 5] na mga halaga. Bukod pa rito, dalawang variable, 'simula' at 'end', ay nakatakda sa 0 at 3, ayon sa pagkakabanggit. Tinutukoy ng mga variable na ito ang hanay ng mga indeks sa slice na 'n' na pag-uuri-uriin. Ang function na 'sort.Slice()' ay tinatawag na may sub-slice na 'n[start:end]' bilang ang unang argumento. Ang sub-slice na ito ay naglalaman ng mga elemento ng 'n' sa loob ng tinukoy na hanay. Pagkatapos nito, ibinibigay ang isang function ng pag-uuri bilang pangalawang argumento sa loob ng function na sort.Slice().
Dito, nakakatanggap ang function na iyon ng dalawang indeks, 'i' at 'j', na kumakatawan sa mga elemento sa loob ng sub-slice. Upang ihambing ang mga elemento sa loob ng sub-slice, ina-access ng sorting function ang mga kaukulang elemento sa orihinal na slice gamit ang simula offset. Inihahambing nito ang n[start+i] at n[start+j]. Susunod, ginagamit ng sort.Slice() function ang ibinigay na function ng pag-uuri upang muling ayusin ang mga elemento sa loob ng sub-slice sa pataas na pagkakasunod-sunod.
Ang sumusunod na output ay nagpapakita na ang mga elemento sa loob ng tinukoy na hanay (simula sa dulo-1) ay pinagsunod-sunod, at ang mga elemento sa labas ng hanay ay nananatiling hindi nagbabago:
Halimbawa 3: Golang Sort Integer Slice Gamit ang Sort.Ints() Function
Bukod dito, ang pinaka-maginhawang pag-uri-uriin ang mga hiwa ng integer ay ang sort.Ints() function nang hindi nangangailangan ng pagpapatupad ng mga custom na paraan ng pag-uuri. Direkta itong gumaganap sa mga hiwa ng integer at nagsasagawa ng in-place na pag-uuri. Ang sumusunod na programa ay nag-uuri ng mga tinukoy na integer:
pakete pangunahingangkat (
'fmt'
'uri'
)
func pangunahing () {
IntSlice := [] int { 10 , 13 , labinlima , labing-isa , 14 , 12 }
fmt . Println ( 'Hindi pinagsunod-sunod na hiwa:' , IntSlice )
uri . Ints ( IntSlice )
fmt . Println ( 'Inayos na hiwa:' , IntSlice )
}
Una, ipinapahayag at pinasimulan namin ang slice na 'IntSlice' na may mga [10, 13, 15, 11, 14, 12] na mga halaga na kumakatawan sa isang koleksyon ng mga integer na una ay hindi naayos. Pagkatapos, ang sort.Ints() function ay tinatawag na may 'IntSlice' slice bilang argumento para pagbukud-bukurin ang 'IntSlice'. Ang sort.Ints() function sa kasong ito ay panloob na nag-uuri ng bawat bahagi ng slice ayon sa isang na-optimize na algorithm ng pag-uuri. Direktang binabago nito ang orihinal na hiwa, muling inaayos ang mga elemento nito sa isang pinagsunod-sunod na pagkakasunud-sunod.
Ang sumusunod na output ay unang nagpapakita na ang unsorted slice ay unang ipinapakita, na sinusundan ng pinagsunod-sunod na slice:
Halimbawa 4: Golang Sort String Slice
Nag-aalok din ang Go ng sort.Strings() function ng sort package na ginagamit upang pagbukud-bukurin ang isang slice ng mga string sa isang partikular na pagkakasunud-sunod. Dito, tinutulungan ng sumusunod na programa ang pag-uri-uriin ang slice ng mga string:
pakete pangunahingangkat (
'fmt'
'uri'
)
func pangunahing () {
strSl := [] string { 'golan' , 'python' , 'java' , 'perl' , 'typescript' }
uri . Mga string ( strSl )
fmt . Println ( strSl )
}
Una naming itinatag ang slice na 'strSl' gamit ang mga value ng ['golang', 'python', 'java', 'perl', 'typescript'] na hindi pinagsunod-sunod. Pagkatapos nito, pinag-uuri-uriin namin ang slice na 'strSl' gamit ang sort.Strings() function na nag-uuri ng mga elemento ng slice sa lexicographic order. Direktang binago ng function na ito ang orihinal na hiwa, muling inaayos ang mga elemento nito sa pinagsunod-sunod na pagkakasunud-sunod batay sa kanilang mga halaga ng ASCII.
Ang output ay nag-uuri ng string slice sa pataas na paraan tulad ng ipinapakita sa sumusunod:
Halimbawa 5: Golang Check Sort Slice Gamit ang IntAreSort() Function
Gayunpaman, gamit ang sort.IntsAreSorted() function ng Go, masusuri natin kung ang isang hiwa ng integer ay pinagsunod-sunod sa pataas na pagkakasunud-sunod o hindi. Isaalang-alang ang sumusunod na halimbawang programa ng IntAreSort() function para sa ibinigay na slice:
pakete pangunahingangkat (
'fmt'
'uri'
)
func pangunahing () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Mga hiwa:' )
fmt . Println ( 'Unsorted Slice: ' , sl )
resulta := uri . IntsAreSorted ( sl )
fmt . Println ( ' \n Resulta:' )
fmt . Println ( 'Binigay ba ang Slice?: ' , resulta )
}
Una, ang isang unsorted slice ng random integers ay tinukoy bilang 'sl'. Ang slice na ito ay naglalaman ng isang koleksyon ng mga integer sa walang partikular na pagkakasunud-sunod. Susunod, tinatawag namin ang sort.IntsAreSorted() function at ipasa ang “sl” slice bilang argumento. Ang function na ito ay nagbibigay ng Boolean na resulta na nagsasaad kung ang slice input ay nakaayos sa pataas na pagkakasunud-sunod. Pagkatapos, ang fmt.Println() function ay nagpi-print ng mga resulta na naglalabas kung ang ibinigay na slice ay pinagsunod-sunod o hindi batay sa ibinalik na Boolean na halaga.
Ang output ay nagpapakita ng false para sa pagkakasunud-sunod ng pag-uuri ng isang slice ng mga integer dahil hindi ito naayos:
Halimbawa 6: Golang Reverse Sort Slice
Dagdag pa, gamit ang sortReverse() at sortStringSlice() na mga function mula sa sort package sa Go, maaari tayong mag-reverse-sort ng slice ng mga string. Ang sumusunod na programa ay nagpapakita ng paggana ng sort.Reverse() function:
pakete pangunahingangkat (
'fmt'
'uri'
)
func pangunahing () {
vowelSlice := [] string { 'Ito ay' , 'a' , 'ako' , 'sa' , 'O' }
fmt . Println ( 'Bago pagbukud-bukurin :' , vowelSlice )
uri . Pagbukud-bukurin ( uri . Reverse ( uri . StringSlice ( vowelSlice )))
fmt . Println ( 'Pagkatapos pagbukud-bukurin :' , vowelSlice )
}
Magsisimula tayo sa pamamagitan ng pagtukoy ng isang slice ng 'vowelSlice' string na naglalaman ng mga vowel na 'e', 'a', 'i', 'u', at 'o'. Ang paunang nilalaman ng tinukoy na hiwa ng mga string ay unang naka-print gamit ang function na 'print'. Susunod, ang pagpapatakbo ng pag-uuri ay isinasagawa gamit ang sort.Sort() function na may sort.Reverse() at sort.StringSlice() function bilang mga argumento. Dito, ang 'sort.Reverse()' ay lumilikha ng bagong uri na binabaligtad ang pagkakasunud-sunod ng mga elemento. Kinukuha nito ang uri ng 'sort.StringSlice' bilang argument nito na nagko-convert sa vowelSlice sa isang uri ng sortable.
Ang output dito ay nagpapakita ng mga patinig sa reverse alphabetical order:
Konklusyon
Sinuri namin ang iba't ibang mga function ng pag-uuri na may mga halimbawa na nag-uuri ng ibinigay na slice. Tinalakay din namin ang tungkol sa pag-uuri ng mga sub-slice at pagsuri kung naayos na ang isang slice. Kaya naman, maaari nating gamitin ang mga kakayahan ng sort package para harapin ang malawak na hanay ng mga hamon sa pag-uuri sa kanilang mga proyekto sa Go.