Пример 1: Golang Сортиране във възходящ ред
Функцията „sort.Slice()“ е най-важната функция в Go, която пренарежда елементите на среза във възходящ или низходящ ред. Вземете под внимание следната илюстрация, където частта е подредена във възходящ ред:
пакет основенимпортиране (
'fmt'
'вид'
)
функ основен () {
evenSlice := [] вътр { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( „Несортиран срез:“ , evenSlice )
вид . Нарязани ( evenSlice , функ ( аз , й вътр ) bool {
връщане evenSlice [ аз ] < evenSlice [ й ]
})
fmt . Println ( „Сортиран срез:“ , evenSlice )
}
В началото на функцията main() ние дефинираме среза evenSlice със стойностите {10, 2, 8, 4, 0, 6}. Този дял представлява колекция от четни числа, които първоначално не са сортирани. За да сортирате среза evenSlice, функцията sort.Slice() се използва със среза. Вътре във функцията sort.Slice() се предоставя функция за сортиране като аргумент. Тази функция определя реда на сортиране чрез сравняване на двата елемента на среза с индекси „i“ и „j“. Ако evenSlice[i] е по-малко от evenSlice[j], той връща true; в противен случай връща false. Функцията sort.Slice() използва тази функция за сравнение, за да пренареди елементите на среза „evenSlice“ във възходящ ред.
Резултатите от сортирания срез във възходящ ред се генерират в следния изходен екран:
Пример 2: Golang Sort Part Slice
След това сортирането се прилага към подсреза на посочения срез във възходящ ред с помощта на функцията sort.Slice() в Go.
пакет основен
импортиране (
'fmt'
'вид'
)
функ основен () {
н := [] вътр { 9 , 7 , 3 , 5 }
започнете := 0
край := 3
вид . Нарязани ( н [ започнете : край ], функ ( аз , й вътр ) bool {
връщане н [ започнете + аз ] < н [ започнете + й ]
})
fmt . Println ( н )
}
Първоначално създаваме среза „n“ със стойностите [9, 7, 3, 5]. Освен това две променливи, „начало“ и „край“, са зададени съответно на 0 и 3. Тези променливи дефинират диапазона от индекси в 'n' среза, който ще бъде сортиран. След това функцията “sort.Slice()” се извиква с подсреза “n[start:end]” като първи аргумент. Този подсрез съдържа елементите на „n“ в посочения диапазон. След това се дава функция за сортиране като втори аргумент във функцията sort.Slice().
Тук тази функция получава два индекса, „i' и „j', които представляват елементите в рамките на подсреза. За да сравни елементите в рамките на подсреза, функцията за сортиране осъществява достъп до съответните елементи в оригиналния срез, като използва началото отместване.Той сравнява n[start+i] и n[start+j].След това функцията sort.Slice() използва предоставената функция за сортиране, за да пренареди елементите в рамките на подсреза във възходящ ред.
Следният изход показва, че елементите в посочения диапазон (от начало до край-1) са сортирани, а елементите извън диапазона остават непроменени:
Пример 3: Golang Сортиране на целочислен отрязък с помощта на функцията Sort.Ints().
Освен това най-удобният начин за сортиране на частите от цели числа е функцията sort.Ints(), без да е необходимо прилагането на потребителски методи за сортиране. Той действа директно върху цели числа и извършва сортиране на място. Следната програма сортира посочените цели числа:
пакет основенимпортиране (
'fmt'
'вид'
)
функ основен () {
IntSlice := [] вътр { 10 , 13 , петнадесет , единадесет , 14 , 12 }
fmt . Println ( „Несортиран срез:“ , IntSlice )
вид . Ints ( IntSlice )
fmt . Println ( „Сортиран срез:“ , IntSlice )
}
Първо, ние декларираме и инициализираме среза „IntSlice“ със стойностите [10, 13, 15, 11, 14, 12], които представляват колекция от цели числа, които първоначално не са сортирани. След това функцията sort.Ints() се извиква със среза „IntSlice“ като аргумент за сортиране на „IntSlice“. Функцията sort.Ints() в този случай вътрешно сортира всяка част от среза според оптимизиран алгоритъм за сортиране. Той модифицира директно оригиналния срез, пренареждайки неговите елементи в сортиран ред.
Следният изход първо показва, че първо се показва несортираният срез, последван от сортирания срез:
Пример 4: Сортиран низ на Golang
Go също предлага функцията sort.Strings() на пакета за сортиране, който се използва за сортиране на част от низове в определен ред. Тук следната програма помага за сортиране на част от низове:
пакет основенимпортиране (
'fmt'
'вид'
)
функ основен () {
strSl := [] низ { 'голан' , 'питон' , 'java' , 'perl' , 'машинопис' }
вид . струни ( strSl )
fmt . Println ( strSl )
}
Първо създадохме среза „strSl“ със стойностите [„golang“, „python“, „java“, „perl“, „typescript“], които не са сортирани. След това сортираме среза „strSl“ с функцията sort.Strings(), която сортира елементите на среза в лексикографски ред. Тази функция модифицира директно оригиналния срез, пренареждайки неговите елементи в сортиран ред въз основа на техните ASCII стойности.
Резултатът сортира среза на низа по възходящ начин, както е показано в следното:
Пример 5: Отрязък за сортиране на проверка на Golang с помощта на функцията IntAreSort().
С функцията sort.IntsAreSorted() на Go обаче можем да проверим дали даден отрязък от цели числа е сортиран във възходящ ред или не. Разгледайте следната примерна програма на функцията IntAreSort() за дадения срез:
пакет основенимпортиране (
'fmt'
'вид'
)
функ основен () {
сл := [] вътр { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Филийки:' )
fmt . Println ( „Несортиран срез:“ , сл )
резултат := вид . IntsAreSorted ( сл )
fmt . Println ( ' \н Резултат:' )
fmt . Println ( „Сортиран ли е даденият отрязък?:“ , резултат )
}
Първо, несортиран отрязък от произволни цели числа се дефинира като 'sl'. Този срез съдържа колекция от цели числа без конкретен ред. След това извикваме функцията sort.IntsAreSorted() и предаваме среза „sl“ като аргумент. Тази функция осигурява булев резултат, който показва дали входът на среза е подреден във възходящ ред или не. След това функцията fmt.Println() отпечатва резултатите, които извеждат дали дадения срез е сортиран или не въз основа на върнатата булева стойност.
Изходът показва false за реда на сортиране на част от цели числа, тъй като не е сортиран:
Пример 6: Срез за обратно сортиране на Golang
Освен това, използвайки функциите sortReverse() и sortStringSlice() от пакета за сортиране в Go, можем да сортираме обратно част от низове. Следната програма демонстрира работата на функцията sort.Reverse():
пакет основенимпортиране (
'fmt'
'вид'
)
функ основен () {
vowelSlice := [] низ { 'То е' , 'а' , 'аз' , 'в' , 'О' }
fmt . Println ( „Преди сортиране:“ , vowelSlice )
вид . Вид ( вид . Обратен ( вид . StringSlice ( vowelSlice )))
fmt . Println ( „След сортиране:“ , vowelSlice )
}
Започваме с дефиниране на част от низа „vowelSlice“, който съдържа гласните „e“, „a“, „i“, „u“ и „o“. Първоначалното съдържание на посочения отрязък от низове се отпечатва първо с помощта на функцията „печат“. След това операцията по сортиране се извършва с помощта на функцията sort.Sort() с функциите sort.Reverse() и sort.StringSlice() като аргументи. Тук „sort.Reverse()“ създава нов тип, който обръща реда на елементите. Той приема типа 'sort.StringSlice' като свой аргумент, който преобразува vowelSlice в сортируем тип.
Резултатът тук показва гласните в обратен азбучен ред:
Заключение
Разгледахме различни функции за сортиране с примери, които сортират предоставения срез. Разгледахме също сортирането на подсрезове и проверката дали даден срез вече е сортиран. Следователно можем да използваме възможностите на пакета за сортиране, за да се справим с широк спектър от предизвикателства за сортиране в техните Go проекти.