冒泡排序（Bubble Sort）：从第一个元素开始，依次比较相邻的元素大小，每次选出最大或最小的元素，放到数组的末尾或开头，重复此过程直到整个数组有序。冒泡排序时间复杂度为O(n^2)。
func bubbleSort(arr []int) { n := len(arr) for i := 0; i < n-1; i++ { flag := false //添加flag作为优化 for j := 0; j < n-i-1; j++ { if arr[j] > arr[j+1] { arr[j], arr[j+1] = arr[j+1], arr[j] flag = true } } if !flag { break //表示已经排好序，退出循环 } } }
选择排序（Selection Sort）：从数组中选择最小或最大的元素，将其与数组的第一个元素交换位置，然后从剩余的元素中选择最小或最大的元素，直到整个数组有序。选择排序时间复杂度为O(n^2)。
func selectionSort(arr []int) { n := len(arr) for i := 0; i < n-1; i++ { minIndex := i for j := i + 1; j < n; j++ { if arr[j] < arr[minIndex] { minIndex = j } } if minIndex != i { arr[i], arr[minIndex] = arr[minIndex], arr[i] } } }
插入排序（Insertion Sort）：从数组的第二个元素开始，将该元素插入到已排序的序列中，一直重复比较和移动元素，直到数组完全有序。插入排序的时间复杂度为O(n^2)。
func insertionSort(arr []int) { n := len(arr) for i := 1; i < n; i++ { j := i for j > 0 && arr[j] < arr[j-1] { arr[j], arr[j-1] = arr[j-1], arr[j] j-- } } }
快速排序（Quick Sort）：选择一个枢纽元素，将数组划分为两个子数组，一个子数组中的元素都小于枢纽元素，另一个子数组中的元素都大于或等于枢纽元素。然后对这两个子数组分别进行快速排序，重复此过程，直到整个数组有序。快速排序时间复杂度为O(nlogn)。
func quickSort(arr []int, left, right int) { if left >= right { return } pivot := arr[left] i, j := left, right for i < j { for i < j && arr[j] >= pivot { j-- } if i < j { arr[i] = arr[j] i++ } for i < j && arr[i] < pivot { i++ } if i < j { arr[j] = arr[i] j-- } } arr[i] = pivot quickSort(arr, left, i-1) quickSort(arr, i+1, right) }
归并排序（Merge Sort）：将数组分成两个长度相等的子数组，对每个子数组进行归并排序。然后将两个已排序的子数组归并为一个大的有序数组。归并排序的时间复杂度为O(nlogn)。
func mergeSort(arr []int) []int { n := len(arr) if n <= 1 { return arr } mid := n / 2 left := mergeSort(arr[:mid]) right := mergeSort(arr[mid:]) return merge(left, right) } func merge(left, right []int) []int { res := make([]int, 0) i, j := 0, 0 for i < len(left) && j < len(right) { if left[i] <= right[j] { res = append(res, left[i]) i++ } else { res = append(res, right[j]) j++ } } res = append(res, left[i:]...) res = append(res, right[j:]...) return res }
堆排序（Heap Sort）：将数组构建成最大堆或最小堆，然后不断从堆中取出元素，每取出一个元素就重新平衡堆。最终得到的序列就是有序的。堆排序时间复杂度为O(nlogn)。
func heapSort(arr []int) {
n := len(arr)
for i := n/2 - 1; i >= 0; i-- {
maxHeapify(arr, i, n)
}
for i := n - 1; i > 0; i-- {
arr[0], arr[i] = arr[i], arr[0]
maxHeapify(arr, 0, i)
}
}
func maxHeapify(arr []int, root, size int) {
left := root*2 + 1
right := root*2 + 2
largest := root
if left < size && arr[left] > arr[largest] {
largest = left
}
if right < size && arr[right] > arr[largest] {
largest = right
}
if largest != root {
arr[root], arr[largest] = arr[largest], arr[root]
maxHeapify(arr, largest, size)
}
}
