[leetCode刷题笔记]2017.02.21

153. Find Minimum in Rotated Sorted Array

这道题是找最小值，就是用二分法。先看区间内有没有旋转发生（nums[left]>nums[right]），如果有旋转发生，则要进入循环。循环中获得中间值，比较中间值与左边值，如果中间值大于左边值则mid到right之前存在最小值，让left=mid+1反之left到mid中存在最小值，right=mid

class Solution(object):

    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1:
            return nums[0]
        length = len(nums)
        left = 0
        right = length - 1
        while nums[left] > nums[right]:
            mid = (left + right) / 2
            if nums[mid] > nums[right]:
                left = mid + 1
            else:
                right = mid

        return nums[left]

162 Find Peak Element

这道题可以用递归做，如果出现中间值mid大于旁边值mid+1的情况则peak在左边，反之在右边

class Solution(object):
    def findPeakElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        left = 0
        right  = len(nums) - 1
        return self.helper(nums, left, right)
        
        
    def helper(self, nums, left, right):
        if left == right:
            return left
        mid = left + (right - left) / 2
        if nums[mid] > nums[mid + 1]:
            return self.helper(nums, left, mid)
        else:
            return self.helper(nums, mid + 1, right)

154. Find Minimum in Rotated Sorted Array ||

这道题考虑最坏情况就是除了一个最小值之外所有元素都一样，这样只能通过O（n)来做。。。所以不用二分法，用循环吧

class Solution(object):
    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        compare = nums[0]
        
        for element in nums:
            compare = min(element, compare)
            
        return compare

167. Two Sum II - Input array is sorted

很简单的题目。。。用两个指针从两边开始往中间移动。。。

class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        
        left = 0
        right = len(numbers) - 1
        while right > left:
            sum = numbers[left] + numbers[right] 
            if sum > target:
                right = right - 1
            elif sum < target:
                left = left + 1
            else:
                return [left + 1, right + 1]

169. Majority Element

这道题能想到O(n)的解法不是很容易。从网上找了Moore voting algorithm，就是先选择一个当前数element，如果nums[i] == element则count++

nums[i] != element则count--

count = 0时候element = nums[i]

一遍循环走下来，我们总是能得到majority element因为其数量大于其他所有数之和count>0

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # Moore voting algorithm
        
        element = 0
        count = 0
        
        for i in range(len(nums)):
            if count == 0:
                element = nums[i]
                count = 1
            else:
                if element == nums[i]:
                    count += 1
                else:
                    count -= 1
        return element

189. Rotate Array

找了一个很巧的办法时间O(n)空间O(1)

就是对数组分段最后k个为一段，前面n - k为一段。分别对这两段进行旋转

然后再对整个数组进行旋转

class Solution(object):
    def rotate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        # modify k
        k = k % len(nums)
        # reverse segment [1] to [n - k]
        self.reverse(nums, 0, len(nums)-k-1)
        # reverse segment [n - k] to [n]
        self.reverse(nums, len(nums)-k, len(nums) - 1)
        # reverse all
        self.reverse(nums, 0, len(nums) - 1)
    
    
    def reverse(self, nums, start, end):
        while start < end:
            nums[start], nums[end] = nums[end], nums[start]
            start, end = start+1, end-1