day3: 一维数组

搜索旋转排序数组

二分查找，因为数组为分段上升序列，可以使用list[0]做为判断上升与否的判断条件

func search(nums []int, target int) int {
    return binarySearch(nums, target)
}

func binarySearch(list []int, target int) int {
    start, end := 0, len(list)-1
    for start <= end {
        mid := (start + end) >> 1
        if list[mid] == target {
            return mid
        }
        if list[mid] >= list[0] {
            if list[0] <= target && target < list[mid] {
                end = mid - 1
            }else {
                start = mid + 1
            }
        } else {
            if list[mid] < target && target <= list[len(list)-1] {
                start = mid + 1
            }else {
                end = mid - 1
            }
        }
    }
    return -1
}

搜索旋转排序数组||

func search(nums []int, target int) bool {
    return binarySearch(nums, target) >= 0
}

func binarySearch(list []int, target int) int {
    start, end := 0, len(list)-1
    for start <= end {
        mid := (start + end) >> 1
        if list[mid] == target {
            return mid
        }
        if list[mid] == list[start] && list[mid] == list[end] {
            start++
            end--
        }else if list[mid] >= list[start] {
            if list[start] <= target && target < list[mid] {
                end = mid - 1
            }else {
                start = mid + 1
            }
        } else {
            if list[mid] < target && target <= list[len(list)-1] {
                start = mid + 1
            }else {
                end = mid - 1
            }
        }
    }
    return -1
}

寻找旋转排序数组的最小值

func findMin(nums []int) int {
    return binarySearch(nums)
}

func binarySearch(list []int) int {
    start, end, mid := 0, len(list)-1, 0
    for start <= end {
        mid = (start + end) >> 1
        if list[mid] < list[end] {
            end = mid
        }else {
            start = mid + 1
        }

    }
    return list[mid]
}

爬楼梯

func climbStairs(n int) int {
    if n == 1 || n == 2 {
        return n
    }
    dp := make([]int, n)
    dp[0] = 1
    dp[1] = 2

    for i:=2;i<n;i++ {
        dp[i] = dp[i-1]+dp[i-2]
    }
    return dp[n-1]
}

斐波那契数

func fib(n int) int {
    if n <= 1{
        return n 
    }
    dp := make([]int, n+1)
    dp[0] = 0
    dp[1] = 1

    for i:=2;i<=n;i++ {
        dp[i] = dp[i-2]+dp[i-1]
    }
    return dp[n]
}

第N个泰波那契数

func tribonacci(n int) int {
    dp := make([]int, 40)
    dp[0] = 0
    dp[1] = 1
    dp[2] = 1

    for i:=3;i<=n;i++ {
        dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
    }
    return dp[n]
}

猜数字

func game(guess []int, answer []int) int {
    count := 0
    for i:=0;i<len(guess);i++ {
        if guess[i] == answer[i] {
            count++
        }
    }
    return count
}

山峰数组的顶部

func peakIndexInMountainArray(arr []int) int {
    return binarySearch(arr)
}

func binarySearch(list []int) int {
    start, end, index := 0, len(list)-1, 0
    for start <= end {
        mid := (start + end) >> 1
        if list[mid] < list[mid+1] {
            start = mid + 1
        }else {
            index = mid
            end = mid - 1
        }
    }
    return index
}

拿硬币

func minCount(coins []int) int {
    count := 0
    for i:=0;i<len(coins);i++ {
        coin := coins[i]
        for coin > 0 {
            coin = coin - 2
            count++
        }
    }
    return count
}

差的绝对值为K的数对数量

	func countKDifference(nums []int, k int) int {
    count := make(map[int]int)
    pairs := 0
    for _, num := range nums {
        pairs += count[num-k] + count[num+k]
        count[num]++
    }

    return pairs
}

--------------------------------------------------------

almost binary search…