zishuo/lancet
1
0
Fork 0
mirror of https://github.com/duke-git/lancet.git synced 2025-10-19 05:44:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: change var name low -> lowIndex, high -> highIndex

Browse Source
This commit is contained in:
dudaodong
2022-01-17 15:11:33 +08:00
parent 87da6c6816
commit b22be7cade
1 changed files with 29 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
algorithm/sorter.go
View File

@@ -82,29 +82,29 @@ func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
return slice return slice
} }
// QuickSort quick sorting for slice, low is 0 and high is len(slice)-1 // QuickSort quick sorting for slice, lowIndex is 0 and highIndex is len(slice)-1
func QuickSort[T any](slice []T, low, high int, comparator lancetconstraints.Comparator) []T { func QuickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) []T {
if low < high { if lowIndex < highIndex {
p := partition(slice, low, high, comparator) p := partition(slice, lowIndex, highIndex, comparator)
QuickSort(slice, low, p-1, comparator) QuickSort(slice, lowIndex, p-1, comparator)
QuickSort(slice, p+1, high, comparator) QuickSort(slice, p+1, highIndex, comparator)
} }
return slice return slice
} }
// partition split slice into two parts // partition split slice into two parts
func partition[T any](slice []T, low, high int, comparator lancetconstraints.Comparator) int { func partition[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
p := slice[high] p := slice[highIndex]
i := low i := lowIndex
for j := low; j < high; j++ { for j := lowIndex; j < highIndex; j++ {
if comparator.Compare(slice[j], p) == -1 { //slice[j] < p if comparator.Compare(slice[j], p) == -1 { //slice[j] < p
swap(slice, i, j) swap(slice, i, j)
i++ i++
} }
} }
swap(slice, i, high) swap(slice, i, highIndex)
return i return i
} }
@@ -124,13 +124,13 @@ func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
return slice return slice
} }
func sift[T any](slice []T, low, high int, comparator lancetconstraints.Comparator) { func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
i := low i := lowIndex
j := 2*i + 1 j := 2*i + 1
temp := slice[i] temp := slice[i]
for j <= high { for j <= highIndex {
if j < high && comparator.Compare(slice[j], slice[j+1]) == -1 { //slice[j] < slice[j+1] if j < highIndex && comparator.Compare(slice[j], slice[j+1]) == -1 { //slice[j] < slice[j+1]
j++ j++
} }
if comparator.Compare(temp, slice[j]) == -1 { //tmp < slice[j] if comparator.Compare(temp, slice[j]) == -1 { //tmp < slice[j]
@@ -145,23 +145,23 @@ func sift[T any](slice []T, low, high int, comparator lancetconstraints.Comparat
} }
// MergeSort merge sorting for slice // MergeSort merge sorting for slice
func MergeSort[T any](slice []T, low, high int, comparator lancetconstraints.Comparator) []T { func MergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) []T {
if low < high { if lowIndex < highIndex {
mid := (low + high) / 2 mid := (lowIndex + highIndex) / 2
MergeSort(slice, low, mid, comparator) MergeSort(slice, lowIndex, mid, comparator)
MergeSort(slice, mid+1, high, comparator) MergeSort(slice, mid+1, highIndex, comparator)
merge(slice, low, mid, high, comparator) merge(slice, lowIndex, mid, highIndex, comparator)
} }
return slice return slice
} }
func merge[T any](slice []T, low, mid, high int, comparator lancetconstraints.Comparator) { func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator lancetconstraints.Comparator) {
i := low i := lowIndex
j := mid + 1 j := midIndex + 1
temp := []T{} temp := []T{}
for i <= mid && j <= high { for i <= midIndex && j <= highIndex {
//slice[i] < slice[j] //slice[i] < slice[j]
if comparator.Compare(slice[i], slice[j]) == -1 { if comparator.Compare(slice[i], slice[j]) == -1 {
temp = append(temp, slice[i]) temp = append(temp, slice[i])
@@ -172,14 +172,14 @@ func merge[T any](slice []T, low, mid, high int, comparator lancetconstraints.Co
} }
} }
if i <= mid { if i <= midIndex {
temp = append(temp, slice[i:mid+1]...) temp = append(temp, slice[i:midIndex+1]...)
} else { } else {
temp = append(temp, slice[j:high+1]...) temp = append(temp, slice[j:highIndex+1]...)
} }
for k := 0; k < len(temp); k++ { for k := 0; k < len(temp); k++ {
slice[low+k] = temp[k] slice[lowIndex+k] = temp[k]
} }
} }