选择排序
// 交换两个数
func Swap(a *int, b *int) {
var temp = *b
*b = *a
*a = temp
}
// 选择排序
func SelectSort(arr []int) {
size := len(arr)
for i := 0; i < size; i++ {
var Lmin int = i
for j := i + 1; j < size; j++ {
if arr[j] < arr[Lmin] {
Lmin = j
}
}
Swap(&arr[i], &arr[Lmin])
}
}
插入排序
// 插入排序
func InsertSort(arr []int) {
for i := 1; i < len(arr); i++ {
for j := i - 1; j >= 0; j-- {
if arr[j] > arr[j+1] {
var temp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
}
}
}
}
归并排序
//归并排序
func mergeSort(arr []int) []int {
if len(arr) <= 1 {
return arr
}
// 分割数组
middle := len(arr) / 2
left := arr[:middle]
right := arr[middle:]
// 递归地对左右两部分进行归并排序
left = mergeSort(left)
right = mergeSort(right)
// 合并已排序的左右两部分
return merge(left, right)
}
func merge(left, right []int) []int {
result := make([]int, 0)
for len(left) > 0 || len(right) > 0 {
if len(left) > 0 && len(right) > 0 {
// 比较左右两部分的第一个元素
if left[0] <= right[0] {
// 将较小的元素添加到结果中
result = append(result, left[0])
// 从左部分移除已添加的元素
left = left[1:]
} else {
// 将较小的元素添加到结果中
result = append(result, right[0])
// 从右部分移除已添加的元素
right = right[1:]
}
} else if len(left) > 0 {
// 如果右部分为空,将左部分的剩余元素添加到结果中
result = append(result, left...)
break
} else if len(right) > 0 {
// 如果左部分为空,将右部分的剩余元素添加到结果中
result = append(result, right...)
break
}
}
return result
}
快速排序
func quickSort(arr []int) []int {
if len(arr) <= 1 {
return arr
}
pivotIndex := partition(arr)
// 递归地对分区进行快速排序
quickSort(arr[:pivotIndex])
quickSort(arr[pivotIndex+1:])
return arr
}
func partition(arr []int) int {
pivotIndex := len(arr) - 1
pivot := arr[pivotIndex]
i := 0
for j := 0; j < len(arr)-1; j++ {
if arr[j] < pivot {
// 交换元素位置
arr[i], arr[j] = arr[j], arr[i]
i++
}
}
// 将基准元素移动到正确的位置
arr[i], arr[pivotIndex] = arr[pivotIndex], arr[i]
return i
}
希尔排序
func shellSort(arr []int) []int {
n := len(arr)
gap := n / 2
for gap > 0 {
for i := gap; i < n; i++ {
temp := arr[i]
j := i
// 对每个组内的元素进行插入排序
for j >= gap && arr[j-gap] > temp {
arr[j] = arr[j-gap]
j -= gap
}
arr[j] = temp
}
// 缩小间隔
gap /= 2
}
return arr
}
计数排序
func countingSort(arr []int) []int {
// 找到数组中的最大值,以确定计数数组的大小
max := findMax(arr)
// 初始化计数数组
countArray := make([]int, max+1)
// 统计每个元素出现的次数
for _, num := range arr {
countArray[num]++
}
// 根据计数数组重建原始数组
index := 0
for i, count := range countArray {
for count > 0 {
arr[index] = i
index++
count--
}
}
return arr
}
func findMax(arr []int) int {
max := arr[0]
for _, num := range arr {
if num > max {
max = num
}
}
return max
}
桶排序
func bucketSort(arr []float64) []float64 {
if len(arr) <= 1 {
return arr
}
// 初始化桶的数量,这里选择 10
numOfBuckets := 10
buckets := make([][]float64, numOfBuckets)
// 将元素分配到桶中
for _, num := range arr {
index := int(num * float64(numOfBuckets))
buckets[index] = append(buckets[index], num)
}
// 对每个桶内的元素进行排序
for i := 0; i < numOfBuckets; i++ {
sort.Float64s(buckets[i])
}
// 合并有序桶的结果
result := make([]float64, 0, len(arr))
for _, bucket := range buckets {
result = append(result, bucket...)
}
return result
}
堆排序
func heapSort(arr []int) []int {
n := len(arr)
// 构建最大堆
for i := n/2 - 1; i >= 0; i-- {
heapify(arr, n, i)
}
// 逐个从堆中取出元素,重新构建最大堆
for i := n - 1; i > 0; i-- {
// 将堆顶元素(最大值)与当前堆的最后一个元素交换
arr[0], arr[i] = arr[i], arr[0]
// 重新构建最大堆
heapify(arr, i, 0)
}
return arr
}
func heapify(arr []int, n, i int) {
largest := i // 初始化根节点为最大值
leftChild := 2*i + 1 // 左子节点
rightChild := 2*i + 2 // 右子节点
// 比较左子节点与根节点
if leftChild < n && arr[leftChild] > arr[largest] {
largest = leftChild
}
// 比较右子节点与当前最大值节点
if rightChild < n && arr[rightChild] > arr[largest] {
largest = rightChild
}
// 如果最大值节点不是根节点,则交换它们,并递归调整
if largest != i {
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
}
}