为了熟悉Go语言基本用法，用Go实现了一遍常见的排序算法
几个概念
- 原地排序(Sorted in place)算法:就是指空间复杂度是O(1)的排序算法
- 排序算法的稳定性:如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变。
- 有序度和逆序度。有序度是数组中具有有序关系的元素对的个数。有序元素对用数学表达式表示的是:
有序元素对: a[i] <= a[j], 如果 i < j。
对于一个完全有序的数组，比如1,2,3,4,5,6.有序度是 n*(n-1)/2,也就是15.把这种完全有序的数组的有序度叫满有序度。
逆序度是指:
逆序元素对:a[i] > a[j]，如果i <j
逆序度 = 满有序度 - 有序度。我们排序的过程就是一种增加有序度，减少逆序度的过程，最后达到满有序度，就说明排序完成了。
常见排序算法的复杂度
冒泡排序
- 从下面的代码可以看到:冒泡排序是原地排序。
- 冒泡排序在元素相等的时候，不会做交换，所以是稳定排序。
/* 算法描述
* 1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，
这样在最后的元素应该会是最大的数
3. 针对所有的元素重复以上的步骤，除了最后一个
4. 重复步骤1~3，直到排序完成。
*/
func bubuleSort(s []int) {
lenght := len(s)
for i := 0; i < lenght-1; i++ {
for j := 0; j < lenght-1-i; j++ {
if s[j] > s[j+1] {
s[j], s[j+1] = s[j+1], s[j]
}
}
}
}
上面的冒泡排序还可以优化，当某次冒泡操作已经没有数据交换时，说明已经达到完全有序，不用再继续执行后续的冒泡操作了。
func bubuleSort1(s []int) {
lenght := len(s)
flag := false // 提前退出冒泡排序的标志位
for i := 0; i < lenght-1; i++ {
for j := 0; j < lenght-1-i; j++ {
if s[j] > s[j+1] {
flag = true // 表示有数据交换
s[j], s[j+1] = s[j+1], s[j]
}
}
if !flag { // 没有数据交换，提前退出
break
}
}
}
选择排序
/* 算法描述
* 1. 初始状态：无序区为R[1..n]，有序区为空；
2. 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。
该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，
使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
3. n-1趟结束，数组有序化了。
*/
func selectSort(s []int) {
for i := range s {
minIndex := i
for j := i + 1; j < len(s); j++ {
if s[j] < s[minIndex] {
minIndex = j
}
}
s[i], s[minIndex] = s[minIndex], s[i]
}
}
插入排序
- 插入排序是一个原地排序算法
- 插入排序是稳定排序
/* 算法描述
* 一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
* 1. 从第一个元素开始，该元素可以认为已经被排序；
* 2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
* 3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
* 4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
* 5. 将新元素插入到该位置后；
* 6. 重复步骤2~5。
*/
func insertSort(s []int) {
var i, j int
for i = 1; i < len(s); i++ {
current := s[i]
for j = i - 1; j >= 0 && s[j] > current; j-- {
s[j+1] = s[j]
}
s[j+1] = current
}
}
希尔排序
希尔排序(Shell's Sort)是插入排序的一种，又称为"缩小增量排序"(Diminishing Increment Sort)。
- 基本思想:希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
func shellSort(s []int) {
for gap := len(s) / 2; gap > 0; gap /= 2 {
fmt.Printf("gap:%d
", gap)
for i := gap; i < len(s); i++ {
j := i
current := s[i]
for j-gap >= 0 && current < s[j-gap] {
s[j] = s[j-gap]
j -= gap
}
s[j] = current
}
}
}
归并排序
归并排序，就是先把数组从中间分成前后两个部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。
/* 算法描述
* 1. 把长度为n的输入序列分成两个长度为n/2的子序列
2. 对这两个子序列分别采用归并排序
3. 将两个排序好的子序列合并成一个最终的排序序列
*/
func mergeSort(s []int) []int {
length := len(s)
if length < 2 {
return s
}
middle := length / 2 // 步骤1
leftSlice := mergeSort(s[0:middle]) // 步骤2
rightSlice := mergeSort(s[middle:length]) // 步骤2
result := merge(leftSlice, rightSlice) // 步骤3
return result
}
func merge(left []int, right []int) []int {
var result []int
leftIndex, rightIndex := 0, 0
for leftIndex < len(left) && rightIndex < len(right) {
if left[leftIndex] <= right[rightIndex] {
result = append(result, left[leftIndex])
leftIndex++
} else {
result = append(result, right[rightIndex])
rightIndex++
}
}
for leftIndex < len(left) {
result = append(result, left[leftIndex])
leftIndex++
}
for rightIndex < len(right) {
result = append(result, right[rightIndex])
rightIndex++
}
return result
}
快速排序
快速排序的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
- 从数列中挑出一个元素，称为"基准"(pivot)
- 重新排列数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面(相同的数可以放到任一边)。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区(partition)操作
- 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。
双边循环法
/********************** 快速排序 ********************************/
func quickSort(s []int, startIndex, endIndex int) {
if startIndex >= endIndex {
return
}
pivotIndex := partition(s, startIndex, endIndex)
quickSort(s, startIndex, pivotIndex-1)
quickSort(s, pivotIndex+1, endIndex)
}
func partition(s []int, startIndex, endIndex int) int {
var (
pivot = s[startIndex]
left = startIndex
right = endIndex
)
for left != right {
for left < right && s[right] > pivot {
right--
}
for left < right && s[left] <= pivot {
left++
}
if left < right {
s[left], s[right] = s[right], s[left]
}
}
s[startIndex], s[left] = s[left], s[startIndex]
return left
}
标准库：sort包
上面自己写的代码纯粹是为了熟悉Go语言，毕竟刚开始学。其实，如果需要对一组数据进行排序, Go语言中有一个标准库sort。
具体使用方法可参考:
https://studygolang.com/pkgdoc
https://blog.csdn.net/gongpulin/article/details/80843921