go语言的冒泡 选择 快排 二分 算法实现

冒泡算法的实现：

func bubbleSort(arr []int) []int {
	n := len(arr)
	for i := 0; i < n-1; i++ {
		for j:=0;j<n-1-i;j++{
			if arr[j]>arr[j+1]{
				arr[j],arr[j+1] = arr[j+1],arr[j]
			}
		}
	}
	return arr
}
           

选择排序的实现：

func selectSort(arr []int) []int {
	n := len(arr)
	for i:=0;i<n-1;i++{
		index := i
		for j:=i+1;j<n;j++{
			if arr[index]>arr[j]{
				index = j
			}
		}
		arr[i],arr[index] = arr[index],arr[i]
	}
	return arr
}
           

go 快速排序实现

func main() {
	a := []int{12,2,23,-1,-3, 29,39}
	quickSort(a, 0, len(a)-1)
	fmt.Println(a)
}
// 快速排序
func quickSort(a []int, left, right int) {
	if left >= right {
		return
	}
	temp := a[left]
	start := left
	stop := right
	for right != left {
		for left < right && a[right] >= temp {
			right--
		}
		for left < right && a[left] <= temp {
			left++
		}
		if left < right {
			a[left], a[right] = a[right], a[left]
		}
	}
	a[right], a[start] = temp, a[right]
	quickSort(a, start, left)
	quickSort(a, right+1, stop)
}


# 另外一种写法

func quickSort(arr []int, start, end int) {
	if start < end {
		i, j := start, end
		key := arr[(start+end)/2]
		for i <= j {
			for arr[i] < key {
				i++
			}
			for arr[j] > key {
				j--
			}
			if i <= j {
				arr[i], arr[j] = arr[j], arr[i]
				i++
				j--
			}
		}

		if start < j {
			quickSort(arr, start, j)
		}
		if end > i {
			quickSort(arr, i, end)
		}
	}
}

func main() {
	arr := []int{3, 7, 9, 8, 38, 93, 12, 222, 45, 93, 23, 84, 65, 2}
	quickSort(arr, 0, len(arr)-1)
	fmt.Println(arr)
}
           

go 二分查找

func half(arr []int,target int) int {
	start := 0
	end := len(arr)

	for start<= end {
		middle := (start+end)/2
		if target == arr[middle]{
			return middle
		}
		if target >arr[middle]{
			start = middle+1
		}else{
			end = middle-1
		}
	}
	return -1
}