旋转数组

189. 旋转数组

• 暴力求解，时间复杂度最大O(N^2)

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

• 利用额外数组，空间和时间复杂度都是O(N)

func rotate(nums []int, k int)  {   
    n := len(nums)
    k = k % n
    if k == 0 {
        return 
    }
    tmp := make([]int,n)
    copy(tmp,nums)
    for i:=0;i<n;i++{
        if i < k {
            nums[i] = tmp[n-k+i]
        }else {
            nums[i] = tmp[i-k]
        }
    }
    return
}

• 旋转，没有额外空间，时间复杂度O(N)

func rotate(nums []int, k int)  {   
    n := len(nums)
    k = k % n
    if k == 0 {
        return 
    }
    // 整个旋转，在分别旋转前k个和后面n-k个
    reverse(nums)
    reverse(nums[:k])
    reverse(nums[k:])
    return
}

func reverse(nums []int){
    n := len(nums)
    for i :=0;i<n/2;i++{
        nums[i],nums[n-1-i] = nums[n-1-i],nums[i]
    }
}

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

解法1，遍历，时间复杂度O(N)

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

解法2，二分查找，时间复杂度O(log(N))

func findMin(nums []int) int {
    n := len(nums)
    if n == 0 {
        return 0
    }
    l,r := 0,n-1
    // 没有旋转
    if nums[l] < nums[r] {
        return nums[l]
    }

    // 对于旋转过的，如果中间大于左边，比如2，3，4，5，6，1。去中间的右边查找
    // 如果中间小于左边，去中间的6，1，2，3，4，5，去中间的左边找
    for l < r {
        mid := l + (r-l)/2
        // 终止条件
        if mid > 0 && nums[mid] < nums[mid-1] {
            return nums[mid]
        }else if mid + 1 < n && nums[mid] > nums[mid+1]{
            return nums[mid+1]
        }
        if nums[mid]>nums[l]{
            l = mid
        }else {
            r = mid
        }
    }
    return nums[l]
}