（LeetCode）数组

0. 总结

数组问题的求解没有固定的模式，只能见一个解一个。

1. 多数元素

169. majority-element

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int

        1. Counter
            return Counter(nums).most_common(1)[0][0]
        2. 统计频次，取最大
     ** 3. 摩尔投票法（从第一个数开始count=1，遇到相同的就加1，遇到不同的就减1，减到0就重新换个数开始计数）
            相互抵消法
        """
        major = nums[0]
        count = 1
        for i in range(len(nums)):
            if i == 0:
                continue
            if major == nums[i]:
                count += 1
            else:
                count -= 1
            if count == 0:
                major = nums[i+1]
        return major

2. 找到所有数组中消失的数字

448. find-all-numbers-disappeared-in-an-array

class Solution(object):
    def findDisappearedNumbers(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]

        笨办法
            集合相减
        
        聪明方法
            将数组元素值a当成下标，如果元素a出现，就把a位置的值设置为负数；
            一轮完成后，没变（正负）号的索引就是我们要找到元素
        """
        for num in nums:
            nums[abs(num)-1] = -abs(nums[abs(num)-1])

        l = []
        for i in range(len(nums)):
            if nums[i] > 0:
                l.append(i+1)
        
        return l

3. 最短无序连续子数组

581. shortest-unsorted-continuous-subarray

class Solution(object):
    def findUnsortedSubarray(self, nums):
        """
        :type nums: List[int]
        :rtype: int

        思路
            先对原数组进行排序，生成一个新数组
            两个数组对比，不同的那段就是最短无序连续子数组
        """
        if len(nums) <= 1:
            return 0
        
        sorted_nums = sorted(nums)
        start, end = 0, len(nums)-1
        for i in range(len(nums)):
            if nums[i] == sorted_nums[i]:
                start += 1
            else:
                break
        for j in range(len(nums)-1, 0, -1):
            if nums[j] == sorted_nums[j]:
                end -= 1
            else:
                break
        
        return end - start + 1 if start < end else 0

4. 除自身以外数组的乘积

238. product-of-array-except-self/

class Solution(object):
    def productExceptSelf(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]

        笨办法
            暴力计算, O(N^2)复杂度
            但不符合题意
        
        聪明法
            用辅助空间, 设置L、R两个数组
            L[i]存放i位置前所有元素的累乘结果, R[i]存放i位置后所有元素的累乘结果
            最终结果 result[i] = L[i] * R[i]
        """
        L, R = [], [0]*len(nums)

        for i in range(len(nums)):
            ele = 1 if i == 0 else L[i-1]*nums[i-1]
            L.append(ele)
        
        for i in range(len(nums)-1, -1, -1):
            ele = 1 if i == len(nums)-1 else R[i+1]*nums[i+1]
            R[i] = ele
        
        result = [L[i]*R[i] for i in range(len(nums))]
        
        return result

5. 旋转图像

48. rotate-image

class Solution(object):
    def rotate(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.

        思路
            先转置、再列反转
        """
        n = len(matrix)

        # 转置
        for i in range(n):
            for j in range(i, n):
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
        
        # 列反转
        for i in range(n):
            matrix[i].reverse()

6. 根据身高重建队列

406. queue-reconstruction-by-height

class Solution(object):
    def reconstructQueue(self, people):
        """
        :type people: List[List[int]]
        :rtype: List[List[int]]

        思路
            先按照h从大到下排序, 再按照k从小到大排序
            迭代, 按照k往结果内相应位置插入
            https://leetcode-cn.com/problems/queue-reconstruction-by-height/solution/gen-ju-shen-gao-zhong-jian-dui-lie-by-leetcode/
        """
        people.sort(key=lambda person: (-person[0], person[1]))

        result = []
        for person in people:
            result.insert(person[1], person)
        
        return result