排序算法的GO语言实现
排序
冒泡排序
func BubbleSort(arr []int,arrLength int){
for i:=0; i<arrLength; i++{
flag := false
//每一轮操作完，有i个元素已经是有序的,同时最后一个元素没有比较对象，不用比
for j:=0;j<arrLength-i-1;j++{
if arr[j] > arr[j+1]{
arr[j],arr[j+1] = arr[j+1],arr[j]
flag = true
}
}
if !flag{
break
}
}
}
插入排序
把数字插入到合适的位置
package algo
import "testing"
/**
第一个数字是有序的，从后面的数字取一个出来，放在有序范围内
*/
func insertionSort(arr []int,arrLength int){
if arrLength <= 1 {
return
}
for i:=1; i<arrLength; i++ {
//从没有排序的区域取第一个
value := arr[i]
//从后往前，跟有序区域每一个数字比较
j := i-1 //i-1是有序区域最后一个数字
for ;j>=0;j--{
//如果值比某个数字小，则该数字需要往后挪动一个位置
if(arr[j] > value){
arr[j+1] = arr[j]
}else{
//有序区域已经没有比该数字更大，退出
break
}
}
//把数字放在挪动出来的空位，j+1是为了补偿j--
arr[j+1] = value
}
}
选择排序
每次选择后面最小的数字放到有序区
//在无序区选择一个最小的数字放在有序区后面
func selectSort(arr []int,arrLength int){
for i:=0; i<arrLength; i++{
minIndex := i //先记录当前元素作为最小元素的索引
//在无序区(i+1)，从前往后找最小的索引
for j:=i+1;j<arrLength;j++{
if arr[j] < arr[minIndex] {
minIndex = j
}
}
//用最小元素替换有序区末尾元素，此时该区域(0~i)才是真正有序
arr[minIndex],arr[i] = arr[i],arr[minIndex]
}
}
快排
选择一个数字作为基准值，小的放左边，基准值放中间，大的放右边。不断重复这个过程
/**
选择一个数字作为基准值，小的放左边，大的放右边
*/
func QuickSort(arr []int){
QuickSortInner(arr,0,len(arr)-1)
}
func QuickSortInner(arr []int,left int,right int){
//递归结束条件，左右两边的索引重合，表示已经所有条件
if(left >= right){
return
}
q := partition(arr,left,right) //分区，并返回两个区中间数的索引
partition(arr,left,q-1) //对小数区[left,q-1]分区
partition(arr,right,q+1)//对大数区分区
}
func partition(arr []int,left int,right int) int{
//选取最后一个值作为基准值
pivot := arr[right]
//有序区开始
j := left
//从左到右遍历，如果某个数字比基数小，该数字加入（交换） 已小数字区间[left,j-1]尾部，区间扩充
//否则加入大数字区间，区间位置不变
//（小->大)
for i:=left;i<right;i++{
if arr[i] < pivot {
arr[i],arr[j] = arr[j],arr[i]
j++
}
}
//基数需要跟大数字区间第一个数字交换（因为比他大的都放在第一个数字后了）
arr[j],arr[right] = arr[right],arr[j]
return j
}
归并排序
把数组不断拆分成两半，直到成为一个单独的元素，然后传入数组的起点，中间点，终点，以中间点为边界合并两个有序的数组
func mergerSort(arr []int,start int,end int){
//start >= end 表示整个数组已经拆分成一个个元素
if start >= end {
return
}
//把数组分成两半,分别对两半进行拆分
middle := start + (end - start) / 2
mergerSort(arr,start,middle)
mergerSort(arr,middle+1,end)
//拆分完后对两半进行合并操作
merge(arr,start,middle,end)
}
//对两个有序数组进行合并操作,i是起点到中间点，j是中间点+1到终点
func merge(arr []int,start int, middle int, end int){
//分别设置三个变量，两个作为有序数组的偏移量，k作为新数组的偏移量
i := start
j := middle+1
k := 0
//申请一个两个数组合并后大小的空间
tmpArr := make([]int,end-start+1)
//循环结束的条件是 其中一个数组已经遍历完
//遍历的过程中新数组递加
for ;i<=middle && j<=end; k++ {
//把值更大的元素放入新数组，并且用该数组下一个元素对比
if arr[j] > arr[i]{
tmpArr[k] = arr[j]
j++
}else{
tmpArr[k] = arr[i]
i++
}
}
//把i数组未循环完的元素放入临时变量
for ;i<=middle;i++{
tmpArr[k] = arr[i]
k++
}
//把j数组未循环完的元素放入临时变量
for ;j<=end;j++{
tmpArr[k] = arr[j]
k++
}
//把新数组的元素放回原数组，原数组需要从起点start偏移
for i=0; i< len(tmpArr); i++{
arr[start+i] = tmpArr[i]
}
}
二分法
等值查找
场景：有序数据
注意点:
- 循环退出条件是 low <= high
- low和high的更新，low=mid+1，high=mid-1。注意这里的 +1 和 -1，如果直接写成 low=mid 或者 high=mid，就可能会发生死循环。
func bsearch(arr []int,value int) int{
length := len(arr)
high := length - 1
low := 0
for high >= low {
mid := low + (high - low)/2
if value == arr[mid] {
return mid
}else if(value > arr[mid]){
low = mid + 1
}else{
high = mid - 1
}
}
return -1
}
查找第一个大于等于value的元素
- 如果 a[mid]小于要查找的值 value，那要查找的值肯定在[mid+1, high]之间，所以，我们更新 low=mid+1。
- 对于 a[mid]大于等于给定值 value 的情况，我们要先看下这个 a[mid]是不是我们要找的第一个值大于等于给定值的元素。如果 a[mid]前面已经没有元素，或者前面一个元素小于要查找的值 value，那 a[mid]就是我们要找的元素。
- 如果 a[mid-1]也大于等于要查找的值 value，那说明要查找的元素在[low, mid-1]之间，所以，我们将 high 更新为 mid-1。
func bsearch(arr []int,value int) int{
length := len(arr)
high := length - 1
low := 0
for low <= high {
mid := low + (high - low)/2
//找到了一个大于等于value的元素
if arr[mid] >= value {
//看看它前面有没有元素
//看看前一个元素是不是小于value
//都符合表示找到了
if mid == 0 || arr[mid - 1] < value {
return mid
}else{
//否则从mid前面找比value大的元素
high = mid - 1
}
}else{
//从后面找
low = mid + 1
}
}
return -1
}
