（LeetCode）數組

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