各种排序用go实现-初入门径

 

一共包含 冒泡排序，选择排序，插入排序，快速排序以及堆排序

详细自己看代码吧；

学习go语言的第一周；给自己布置了排序算法用go实现的任务；以后每周记录一周的大任务！

package main

import "fmt"
//冒泡排序
func bsort(ar []int) {

	for i := 0; i < len(ar); i++ {  //花括号{必须在这一行 if也一样
		for j := i + 1; j < len(ar); j++ {
			if ar[i] > ar[j] {
				ar[i], ar[j] = ar[j], ar[i] //相比某语言不需要临时交换变量
			}
		}
	}
}

// 选择排序
func SelectSort(data []int) {
	length := len(data)
	for i := 0; i < length; i++ {
		tmp := data[i]
		flag := i
		for j := i + 1; j < length; j++ {
			if data[j] < tmp {
				tmp = data[j]
				flag = j
			}
		}

		if flag != i {
			data[flag] = data[i]
			data[i] = tmp
		}
		fmt.Println(data) //为了看具体排序的过程

	}
}
//插入排序
func isort(ar []int){
	for i := 0; i < len(ar); i++ {  //花括号{必须在这一行 if也一样
		for j := i; j>0; j--{
			if ar[j] > ar[j-1] {
				break
			}
			ar[j],ar[j-1]=ar[j-1],ar[j]
		}
	}
}

//快速排序  分治法（类似与二分）
func qsort(ar []int,left,right int){
	if left >= right {
		return
	}
	val :=ar[left]
	k:=left
	//确定val的位置
	for i:=left+1;i<=right;i++ {
		if ar[i] < val {
			ar[k]=ar[i]
			ar[i]=ar[k+1]
			k++
		}
	}
	ar[k]=val
	qsort(ar,left,k-1)
	qsort(ar,k+1,right)

}

// 堆排序
func minHeap( ar []int,root int, end int)  {
	for {
		var child = 2*root + 1
		//判断是否存在child节点
		if child > end {
			break
		}
		//判断右child是否存在，如果存在则和另外一个同级节点进行比较
		if child+1 <= end && ar[child] > ar[child+1] {
			child += 1
		}
		if ar[root] > ar[child] {
			ar[root], ar[child] = ar[child], ar[root]
			root = child
		} else {
			break
		}
	}
}
//降序排序
func HeapSort(ar []int)  {
	var n = len(ar)-1
	for root := n / 2; root >= 0; root-- {
		minHeap(ar,root, n)
	}
	fmt.Println("堆构建完成")
	for end := n; end >=0; end-- {
		if ar[0]<ar[end]{
			ar[0], ar[end] = ar[end], ar[0]
			minHeap(ar,0, end-1)
		}
	}
}



func main()  {
	b:=[...]int{8,7,5,4,17,16}
	//bsort(b[:])
	//SelectSort(b[:])
	//isort(b[:])
	//qsort(b[:],0,len(b)-1)
	HeapSort(b[:])
	fmt.Println(b)
	//println("hello world")
}

　　

懒惰是大忌！