go实现的经典排序算法

冒泡排序/选择排序/直接插入/归并排序/快排

package	 main

import "fmt"

func swap(arr *[]int, m,n int){
	temp := (*arr)[m]
	(*arr)[m] = (*arr)[n]
	(*arr)[n] = temp
}

// 冒泡排序
//外层循环是比较的趟数，内层循环是每一趟冒泡：比较相邻的两个数，交换较小者在前，使最小者慢慢浮上来
func bubbleSort(arr *[]int){
	length := len(*arr)
	if length == 0{
		return
	}
	for i := length-1;i>=0;i--{
		for j := length-1;j>=length-i;j--{
			if (*arr)[j] < (*arr)[j-1]{
				swap(arr,j,j-1)
			}
		}
	}
}

func TestBubbleSort(){
	var arr = []int{4,7,3,8,1,5,2,9,6}
	bubbleSort(&arr)
	fmt.Println("冒泡：",arr)
}

//直接插入排序
//将数组分为两部分，前者是有序的，后者是无序的，
//每一趟从无序数组中选择第一个，插入到有序数组正确的位置
func insertSort(arr *[]int){
	length := len(*arr)
	if length == 0{
		return
	}
	for i:=1;i<length;i++{  //第一个数是有序的
		for j := i;j>=1;j--{
			if (*arr)[j] < (*arr)[j-1]{
				swap(arr,j,j-1)
			}
		}
	}
}

func TestInsertSort(){
	var arr = []int{4,7,3,8,1,5,2,9,6}
	insertSort(&arr)
	fmt.Println("直接插入：",arr)
}

//选择排序
//从无序数组红选择一个最小的 放到第一位，再选择一个第二小的，放在第二位，依次类推
func chooseSort(arr *[]int){
	length := len(*arr)
	if length == 0{
		return
	}
	for i:=0;i<length;i++{
		minIndex := i
		for j := length -1;j>=i;j--{
			if (*arr)[j] < (*arr)[minIndex]{
				minIndex = j
			}
		}
		swap(arr,i,minIndex)
	}
}

func TestChooseSort(){
	var arr = []int{4,7,3,8,1,5,2,9,6}
	chooseSort(&arr)
	fmt.Println("直接选择：",arr)
}

//归并排序
// 先划分成长度为length/2 的子数组，继续将子数组划分成长度为length/4，直到长度=1，进行merge
func mergeSort(arr *[]int){
	length := len(*arr)
	if length == 0{
		return
	}
	mergeSortByLen(arr,0,length-1)
}

func mergeSortByLen(arr *[]int, low,high int){
	if low<high{
		mid := (low+high)/2
		mergeSortByLen(arr,low,mid)
		mergeSortByLen(arr,mid+1,high)
		merge(arr,low,mid,high)
	}
}

func merge(arr *[]int,low,mid,high int){
	var brr []int
	var (
		i = low
		j = mid+1
	)
	for i<=mid && j <=high{
		if (*arr)[i] < (*arr)[j]{
			brr = append(brr,(*arr)[i])
			i++
		}else{
			brr = append(brr,(*arr)[j])
			j++
		}
	}
	for i<= mid{
		brr = append(brr,(*arr)[i])
		i++
	}
	for j<=high{
		brr = append(brr,(*arr)[j])
		j++
	}
	for i:=0;i<len(brr);i++{
		(*arr)[low] = brr[i]
		low++
	}
}

func TestMergeSort(){
	var arr = []int{4,7,3,8,1,5,2,9,6}
	mergeSort(&arr)
	fmt.Println("归并：",arr)
}

//快排
func QuickSort(arr *[]int){
	if len(*arr) == 0{
		return
	}
	quick(arr,0,len(*arr)-1)
}
//挖坑填数法，选择一个基数（一般是第一个），两个指针指向头尾，
//比基数小的放在基数的左边，比基数大的放在基数的右边，
func quick(arr *[]int,left,right int){
	low,high := left,right
	pivot := (*arr)[low]
	for low < high{
		for low<high &&  (*arr)[high] > pivot{
			high --
		}
		if low < high{
			(*arr)[low] = (*arr)[high]
			low++
		}
		for low<high &&  (*arr)[low] < pivot{
			low ++
		}
		if low < high{
			(*arr)[high] = (*arr)[low]
			high --
		}
	}
	(*arr)[low] = pivot
	if low - left > 1{
		quick(arr,left,low-1)
	}
	if right-low > 1{
		quick(arr,low+1,right)
	}
}

func TestQuickSort(){
	var arr = []int{7,9,1,4,2,5,3,6,8}
	QuickSort(&arr)
	fmt.Println("快排：",arr)
}

func TestSort(){
	TestBubbleSort()
	TestInsertSort()
	TestChooseSort()
	TestMergeSort()
	TestQuickSort()
}