排序
冒泡排序
func BubbleSort(s []int)[]int{
for i := 0; i < len(s); i ++ {
for j := i + 1; j < len(s); j ++{
if s[i] > s[j]{
s[i],s[j] = s[j],s[i]
}
}
}
return s
}
选择排序
选择是排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，经过和其他元素重整，再依原则交换位置后达到排序目的。
第一次从R[0]-R[n-1]中选出最小值，与R[0]交换，第二次从R[1]-R[n-1]中选取最小值，与R[1]交换，第三次从R[2]-R[n-1]中选取最小值，与R[2]交换，...,第i次从R[i-1]-R[n-1]中选取最小值，与R[i-1]进行交换，...,第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排序的有序序列。
func SelectSort(s []int)[]int{
for i := 0; i < len(s) - 1; i ++ {
// 先假设arr[0]为最小值
min := s[i]
minIndex := i
// 遍历后面1—[len(s)-1]比较
for j := i + 1; j < len(s); j ++ {
if min > s[j] {
// 找到真正的最大值
min = s[j]
minIndex = j
}
}
// 交换操作
if minIndex != i {
s[i], s[minIndex] = s[minIndex],s[i]
}
}
return s
}
插入排序
插入式排序也属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。
把n个待排序的元素看成为一个有序表和一个无需表，开始时，有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码一次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
func InsertSort(s []int)[]int{
// 完成第一次，给第二个元素找到合适的位置并插入
for i := 1; i < len(s); i ++ {
insertVal := s[i]
insertIndex := i - 1
// 从小到大
for insertIndex >= 0 && s[insertIndex] > insertVal{
s[insertIndex + 1] = s[insertIndex]
insertIndex --
}
// 插入
if insertIndex + 1 != i {
s[insertIndex + 1] = insertVal
}
}
return s
}
快速排序
快速排序是对冒泡排序的一种改进，基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据编程有序序列。
// left 表示数组左边的下标
// right 表示数组右边的下标
// array B小时要排序的数组
func QuickSort(left, right int, s []int){
l := left
r := right
// p 是中轴,支点
p := s[(l+r)/2]
//for循环的目的是将比p小的数放到左边，比p大的数放到右边
for; l < r;{
// 从p的左边找到大于等于p的值
for;s[l] < p;{
l ++
}
// 从p的右边找到小于p的值
for;s[r] > p;{
r --
}
// l >= r 表明本次分解任务完成，break
if l >= r {
break
}
// 交换
s[l],s[r] = s[r],s[l]
// 优化
if s[l] == p {
r --
}
if s[r] == p {
l ++
}
}
// 如果l == r, 再移动下
if l == r{
l ++
r --
}
// 向左递归
if left < r{
QuickSort(left,r, s)
}
// 向右递归
if right > l {
QuickSort(l,right,s)
}
}