从零开始刷Leetcode——数组（122.167.169）

122.买卖股票的最佳时机 II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

1.一次遍历

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        max_profit = 0
        for i in range(len(prices)-1):
            if prices[i+1] - prices[i] > 0:
                max_profit += prices[i+1] - prices[i]
        return max_profit

不看答案一脸懵逼，看了答案恍然大悟就是我了。本题实际上很好理解，只要第二天的股价比第一天多就可以买卖，想不明白就多想想。68ms，15MB。其他解法没找到，这个思路应该就是最清晰的了。

167.两数之和II

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明：

• 返回的下标值（index1 和 index2）不是从零开始的。
• 你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

1.双指针

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        i = 0
        j = len(numbers)-1
        while(i < j):
            if numbers[i] + numbers[j] == target:
                return i+1,j+1
            elif numbers[i] + numbers[j] > target:
                j = j-1
            elif numbers[i] + numbers[j] < target:
                i = i+1
            else:
                return -1,-1

和第一题相比本题是有序数组，所以会有更好的方法。此方法用两个指针，一个代表开头，一个代表结尾，若两个指针代表的数相加大于target，说明后边指针应该向前一位，反之亦然。36ms，14.1MB

2.哈希表

和第一题基本一样

3.二分查找

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        for i in range(len(numbers)):
            ans = target - numbers[i]
            k = len(numbers) - 1
            j = i + 1
            while j <= k:
                mid = (j + k) // 2
                if numbers[mid] == ans:
                    return i + 1, mid + 1
                elif numbers[mid] < ans:
                    j = mid + 1
                else:
                    k = mid - 1

固定一个值，另一个值用二分查找，比较慢，68ms，14.1MB

169.多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

1.排序取中间值

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        nums.sort()
        return nums[len(nums)//2]

中间数必为众数，44ms，15.1MB

2.哈希表

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        dict = {}
        for i in nums:
            if i in dict.keys():
                dict[i] +=1
            else:
                dict[i] = 1  
        max = 0
        for j in dict:
            if dict[j] > max:
                max = dict[j]
                index = j
        return index

第一个循环构建哈希表，字典的键为数组的值，字典的值为出现次数，第二次遍历哈希表找到最终解。56ms，15.2MB

3.摩尔投票法

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        value = 0
        count = 0
        for i in nums:
            if count == 0:
                value = i
            if i == value:
                count += 1
            else:
                count -= 1
        return value

摩尔投票法（Boyer–Moore majority vote algorithm），也被称作「多数投票法」，算法解决的问题是：如何在任意多的候选人中（选票无序），选出获得票数最多的那个。

算法可以分为两个阶段：

• 对抗阶段：分属两个候选人的票数进行两两对抗抵消
• 计数阶段：计算对抗结果中最后留下的候选人票数是否有效

56ms，15MB