2022年寒假算法练习第一天(1.10)

**
前言：Golang编写

leetcode

题目：34. 在排序数组中查找元素的第一个和最后一个位置
一般解法：时间复杂度：O(n)，空间复杂度：O(1)；如下↓

func searchRange(nums []int, target int) []int {
    begin := 0
    end := len(nums)-1
    for i := 0;i < len(nums);i++ {
        if nums[i] == target {
            begin = i
            end = i
            for j := i; j < len(nums); j++{
                if nums[j] == target {
                    end = j
                } else {
                    break
                }
            }
            return []int{begin,end}
        }
    }
    return []int{-1, -1}
}

进阶解法：时间复杂度：O(log n)，空间复杂度：O(1)

func searchRange(nums []int, target int) []int {
	left := sort.SearchInts(nums, target)
	// left == len(nums) 这个条件可以筛选数组为空或者是target比数组任何一个数都大的情况，
	if left == len(nums) || nums[left] != target{
		return []int{-1,-1}
	}
	right := sort.SearchInts(nums, target + 1)-1
	return []int{left, right}
}

题目：33. 搜索旋转排序数组

一般解法：时间复杂度：O(n)，空间复杂度：O(1)；如下↓

func search(nums []int, target int) int {
    for i := 0;i < len(nums);i++ {
        if nums[i] == target {
            return i
        }
    }
    return -1
}

进阶解法：时间复杂度：O(log n)，空间复杂度：O(1)；如下↓

// 二分

题目：74. 搜索二维矩阵

最一般的解法：时间复杂度：O(n2)，空间复杂度：O(1)；如下↓

最基础的二维数组遍历

一般解法：时间复杂度：O(n)，空间复杂度：O(1)；如下↓

func searchMatrix(matrix [][]int, target int) bool {
    for i := 0;i < len(matrix);i++ {
        begin := matrix[i][0]
        end := matrix[i][len(matrix[i])-1]
        if begin <= target && end >= target{
            for j := 0;j < len(matrix[i]);j++ {
                if matrix[i][j] == target {
                    return true
                }
            }
            break
        }
    }
    return false
}

进阶解法：时间复杂度：O(log n)，空间复杂度：O(1)；如下↓

func searchMatrix(matrix [][]int, target int) bool {
	r := binSearch1(matrix, target, 0, len(matrix)-1)
	var flag bool
	if r == -1 {
		return true
	} else if r == -2 {
		return false
	} else {
		flag = binSearch2(matrix, target, 1, len(matrix[0])-1, r)
		fmt.Println(flag)
	}
	return flag
}
func binSearch1(matrix [][]int, target, begin, end int) int {
	if begin > end {
		return -2
	}
	mid := (begin + end) / 2
	if matrix[mid][0] == target {
		return -1
	} else if begin == end {
		if begin < target {
            return begin
        } else {
            return -2
        }
	} else if matrix[mid][0] < target && mid+1 < len(matrix) && matrix[mid+1][0] > target {
		return mid
	} else if mid-1 >= 0 && matrix[mid-1][0] < target && matrix[mid][0] > target {
		return mid - 1
	} else if matrix[mid][0] > target {
		return binSearch1(matrix, target, begin, mid-1)
	} else {
		return binSearch1(matrix, target, mid+1, end)
	}
}
func binSearch2(matrix [][]int, target, begin, end, r int) bool {
	if begin > end {
		return false
	}
	mid := (begin + end) / 2
	if matrix[r][mid] == target {
		return true
	} else if matrix[r][mid] > target {
		return binSearch2(matrix, target, begin, mid-1, r)
	} else {
		return binSearch2(matrix, target, mid+1, end, r)
	}
}

题目：剑指 Offer II 001. 整数除法

见到这种题的通用想法就是用减法来代替除法，但是当被除数很大，而除数很小时，那就超出了时间限制，所以需要用进制法来代替。

解法：时间复杂度：O(1)，空间复杂度：O(1)；如下↓

func divide(a int, b int) int {
    ans := 0
    if a == 0 {
        return 0
    }
    if a == math.MinInt32 && b == -1 {
        return math.MaxInt32
    }
    sign := 1
	if (a > 0 && b < 0) || (a < 0 && b > 0) {
		sign = -1
	}
    if a < 0 { a = -a }
    if b < 0 { b = -b }
    for i := 31;i >= 0;i-- {
        if a >> i >= b {
            a -= b << i
            ans += 1 << i
        }
    }
    if sign == -1 {
        return -ans 
    } else {
        return ans 
    }
}

题目：剑指Offer ll 002.二进制加法

解法：时间复杂度：O(n)，空间复杂度：O(1)；如下↓

// 标准的二进制加法，遇 2 进 1
func addBinary(a string, b string) string {
	ans := ""
	carry := 0
	lenA, lenB := len(a), len(b)
	n := max(lenA, lenB)

	for i := 0; i < n; i++ {
		// 将 a 和 b 串 的各个位相加到carry里
		if i < lenA {
			carry += int(a[lenA-i-1] - '0')
		}
		if i < lenB {
			carry += int(b[lenB-i-1] - '0')
		}
		// 字符串拼接， ans要在后，因为是向高位进行推算
		ans = strconv.Itoa(carry%2) + ans
		// 通过除 2 来更新carry值
		// 如果等于2，则carry等于1，需要通过下次循环向高位加一
		// 如果小于2， 则carry为0，不用向高位进一
		carry /= 2
	}
	if carry > 0 {
		ans = "1" + ans
	}
	return ans
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

题目：剑指 Offer II 003. 前 n 个数字二进制中 1 的个数

位运算解法：时间复杂度：O(n)，空间复杂度：O(n)；如下↓

func countBits(n int) []int {
	var ans = make([]int, n+1)
	for i := 0; i <= n; i++ {
		num := 0
		ic := i
		for j := 20; j >= 0; j-- {
			if ic >= 1 << j {
				ic -= 1 << j
				num++
			}
		}
		ans[i] = num
	}
	return ans
}