剑指offer 刷题 二十三 数学（39 66）

剑指 Offer 39. 数组中出现次数超过一半的数字

写了一个快排，时间超了。这题如果是考试，我还是用哈希比较保险。哈希的时间复杂度是O(n)，快排是O(nlogn)。

def majorityElement(self, nums: List[int]) -> int:
        def quicksort(left, right, nums):
            if left >= right: return
            start, end = left, right
            pivot = nums[left]

            while left < right:
                while left < right and nums[right] >= pivot:
                    right -= 1
                while left < right and nums[left] <= pivot:
                    left += 1
                nums[left], nums[right] = nums[right], nums[left]
            nums[left], nums[start] = nums[start], nums[left]
            quicksort(start, right, nums)
            quicksort(left + 1, end, nums)

        quicksort(0, len(nums) - 1, nums)
        return nums[len(nums)//2]

下面是大佬的思路和代码：

下面是数学中众数的定义：
众数（Mode）是指在统计分布上具有明显集中趋势点的数值，代表数据的一般水平。 也是一组数据中出现次数最多的数值，有时众数在一组数中有好几个。用M表示。










根据大佬思路，自己写的代码：

def majorityElement(self, nums: List[int]) -> int:
        votes = 0
        for num in nums:
            if votes == 0:
                mode = num
                votes += 1
            elif num == mode:
                votes += 1
            else: votes -= 1
        return mode

大佬代码：

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

剑指 Offer 66. 构建乘积数组

这道题我只想到了用除法做。
看下大佬的思路和代码吧，数学的题真的不好想。









上三角和下三角相乘，本质上就是B[i]分成左右两边，分别计算2边的乘机，然后最后乘在一起。为什么要这么做呢，就是因为我们无法连乘。

按照大佬的思路，自己写的，超时了。。。

def constructArr(self, a: List[int]) -> List[int]:
        left, right = [1]*len(a), [1]*len(a)
        b = [1]*len(a)
        for i in range(len(a)):
            for j in range(0, i):
                left[i] *= a[j]
            for k in range(i + 1, len(a)):
                right[i] *= a[k]
            b[i] = left[i] * right[i]
        return b

大佬代码：

class Solution:
    def constructArr(self, a: List[int]) -> List[int]:
        b, tmp = [1] * len(a), 1
        for i in range(1, len(a)):
            b[i] = b[i - 1] * a[i - 1] # 下三角
        for i in range(len(a) - 2, -1, -1):
            tmp *= a[i + 1]            # 上三角
            b[i] *= tmp                # 下三角 * 上三角
        return b

下面是Leetcode官方题解：

根据Leetcode的思路，改的代码，通过了

def constructArr(self, a: List[int]) -> List[int]:
        if not a: return []
        length = len(a)
        left, right = [1] * length, [1] * length
        left[0], right[-1] = 1, 1
        res = [1] * length
        for i in range(1, length):
            left[i] = left[i-1] * a[i-1]
        for i in range(length-2, -1, -1):
            right[i] = right[i+1] * a[i+1]
        for i in range(length):
            res[i] = left[i] * right[i]
        return res