使用go语言的排序算法

选择排序

// 交换两个数
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)
	}
}