排序算法题

package code

func BinSearch(nums []int, target int) int {
	left := 0
	right := len(nums) - 1
	for left <= right {
		mid := (right + left) / 2
		switch {
		case nums[mid] == target:
			return mid
		case nums[mid] > target:
			right = mid - 1
		case nums[mid] < target:
			left = mid + 1
		}
	}
	return -1
}

func QuickSort(arr []int) []int {
	count := len(arr)
	if count <= 1 {
		return arr
	}
	var left []int
	var right []int
	base := arr[0]
	for i := 1; i < count; i++ {
		if arr[i] < base {
			left = append(left, arr[i])
		} else {
			right = append(right, arr[i])
		}
	}
	left = append(QuickSort(left), base)
	left = append(left, QuickSort(right)...)
	return left
}

func QuickSortV2(sortArray []int, left, right int) {
	if left < right {
		key := sortArray[(left+right)/2]
		i := left
		j := right

		for {
			for sortArray[i] < key {
				i++
			}
			for sortArray[j] > key {
				j--
			}
			if i >= j {
				break
			}
			sortArray[i], sortArray[j] = sortArray[j], sortArray[i]
		}

		QuickSortV2(sortArray, left, i-1)
		QuickSortV2(sortArray, j+1, right)
	}
}

// 选择排序
func SelectSort(a []int) {
	n := len(a)
	for i := 0; i < n-1; i++ {
		k := i
		for j := i + 1; j < n; j++ {
			if a[j] < a[k] {
				k = j
			}
		}
		a[i], a[k] = a[k], a[i]
	}
}

// 插入排序
func InsertionSort(a []int) {
	n := len(a)
	for i := 1; i < n; i++ {
		temp := a[i]
		j := i - 1
		for ; j >= 0 && a[j] > temp; j-- {
			a[j+1] = a[j]
		}
		a[j+1] = temp
	}
}

// 希尔排序
func ShellSort(a []int) {
	n := len(a)
	for d := n / 2; d >= 1; d /= 2 {
		for i := d; i < n; i++ {
			temp := a[i]
			j := i - d
			for ; j >= 0 && a[j] > temp; j -= d {
				a[j+d] = a[j]
			}
			a[j+d] = temp
		}
	}
}

// 合并一次
func mergeOne(a []int, b []int, n int, len int) {
	i := 0
	for i+len < n {
		j := i + 2*len - 1
		if j >= n {
			j = n - 1
		}
		m := i
		k := i
		l := i + len
		for i < k+len && l <= j {
			if a[i] <= a[l] {
				b[m] = a[i]
				m++
				i++
			} else {
				b[m] = a[l]
				m++
				l++
			}
		}
		for i < k+len {
			b[m] = a[i]
			m++
			i++
		}
		for l <= j {
			b[m] = a[l]
			m++
			l++
		}
		i = j + 1
	}
	if i < n {
		for ; i < n; i++ {
			b[i] = a[i]
		}
	}
}

func MergeSort(a []int) {
	n := len(a)
	b := make([]int, n)
	_len := 1
	flag := 0
	for _len < n {
		if flag == 0 {
			mergeOne(a, b, n, _len)
		}
		if flag == 1 {
			mergeOne(b, a, n, _len)
		}
		flag = 1 - flag
		_len *= 2
	}
	if flag == 1 {
		for i := 0; i < n; i++ {
			a[i] = b[i]
		}
	}
}

// 冒泡排序
func BubbleSort(a []int) {
	n := len(a)
	for i := n; i > 1; i-- {
		for j := 0; j < i-1; j++ {
			if a[j] > a[j+1] {
				a[j], a[j+1] = a[j+1], a[j]
			}
		}
	}
}