go算法排序系列-004二分排序

在一个有序数组中，查找某个数是否存在

func exist(sortedarr []int, num int) bool {
	temp := len(sortedarr)
	if sortedarr == nil || temp == 0 { // 剔除杂项
		return false
	}
	L := 0
	R := temp - 1
	mid := 0
	for L < R {
		mid = L + ((R - L) >> 1) // 这样写无论怎么样都不会越界
		if sortedarr[mid] == num { // 如果正好找到，直接返回
			return true
		} else if sortedarr[mid] > num { // 大了就往左走
			R = mid - 1
			fmt.Println(R)
		} else {
			L = mid + 1 // 小了就往右走
		}
	}
	return sortedarr[L] == num
}

时间复杂度

每一次都是折半查找，所以假设是0(N)的时间复杂度，那么就是2^n = O(N)，那么时间复杂度就为O(logN)

空间复杂度

变量加起来也是O(1)，没有重复的生成额外变量

在一个有序数组中，找>=某个数最左侧的位置

func nearetindex(arr []int, value int) int {
	temp := len(arr)
	L := 0
	R := temp - 1
	index := -1
	for L <= R {
		mid := L + ((R - L) >> 1)
		if arr[mid] >= value { // 如果中间这个值大于等于value，说明左侧有离他最近的值
			index = mid
			R = mid - 1
		} else {
			L = mid + 1
		}
	}
	return index
}

func nearestindex(arr []int, value int) int {
	temp := len(arr)
	L := 0
	R := temp - 1
	index := -1
	for L < R {
		mid := L + ((R - L) >> 1)
		if arr[mid] <= value {
			index = mid
			L = mid + 1
		} else {
			R = mid - 1
		}
	}
	return index
}

局部最小值问题

func getlessindex(arr []int) int {
	temp := len(arr)
	left := 1
	right := temp - 2
	mid := 0
	for left < right {
		// mid = (left + right) / 2
		mid = (left + right) >> 2
		if arr[mid] > arr[mid-1] {
			right = mid - 1
		} else if arr[mid] > arr[mid+1] {
			left = mid + 1
		} else {
			return mid
		}

	}
	return left
}