【Leetcode】top 100 技巧

136 只出现一次的数字

给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

技巧：异或    相同为0，剩到最后的数值只出现一次；

class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        out = 0
        for i in range(len(nums)):
            out = out ^ nums[i]
        return out

169 多数元素

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。

方法一：计数器                                 空间复杂度O(n)

方法二：排序后返回nums[n//2]         时间复杂度O(nlogn)    系统自带排序空间复杂度O(logn)

方法三：Boyer-Moore 投票算法

相似思路：如果一个数组有大于一半的数相同，那么任意删去两个不同的数字，新数组还是会有相同的性质，当删去后的数组仅为同一个值，该值为众数；

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        val, cnt = 0, 0
        for num in nums:
            if not cnt: val = num    # val为0代表前面的都消掉了，重新赋个可能的众数
            
            if num == val: cnt+=1
            else: cnt-=1
        
        return val

75 颜色分类

给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。必须在不使用库内置的 sort 函数的情况下解决这个问题。

方法一：双指针     参考题283的移动零（将所有零移到数组末尾同时保持非零元素的相对位置）

这里需要把2移到数组末尾（正序遍历），把0移到数组开头（倒序遍历）

class Solution(object):
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        left, right, n = 0, 0, len(nums)    # 从左往右将2移到最后
        while right<n:
            if nums[left] != 2:                  #left找2，right找非2
                left, right = left+1, right+1
            else:
                while right<n:
                    if nums[right] != 2:
                        nums[left], nums[right] = nums[right], nums[left]
                        break
                    right += 1
        
        left, right = n-1, n-1             # 从右往左将0移到最先
        while left>=0:          
            if nums[right] != 0:           # right找0，left找非0  
                left, right = left-1, right-1
            else:
                while left>=0:
                    if nums[left] !=0:
                        nums[left], nums[right] = nums[right], nums[left]
                        break
                    left -= 1
        return nums

方法二：双指针   维护0和1的终点坐标  即 [:p0]是0    [p0:p1]是1    [p1:]是2

找到1时将其交换到nums[p1]再将p1+1，找到0时将其交换到nums[p0]再将p0+1，p1+1，但nums[p0]可能是1（当p0<p1时），此时还要把可能的1交换到nums[p1]

同思路，维护p0和p2    

class Solution(object):
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        p0, p1, n = 0, 0, len(nums)
        for i in range(n):
            if nums[i] == 1:
                nums[p1], nums[i] = nums[i], nums[p1]
                p1 += 1
            elif nums[i] == 0:
                nums[p0], nums[i] = nums[i], nums[p0]
                if p0<p1:
                    nums[p1], nums[i] = nums[i], nums[p1]
                p0, p1 = p0+1, p1+1

        return nums

31 下一个排列

字典序：以[1,2,3]为例：[1,2,3] [1,3,2] [2,1,3] [2,3,1] [3,1,2] [3,2,1]，给你一个整数数组 nums ，找出 nums 的下一个排列。必须原地修改，只允许使用额外常数空间。数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

step1：找到最大索引k满足nums[k]<nums[k+1]——倒序遍历找小于后一个元素的第一个元素

             如果不存在就翻转整个数组（此时为最大排列）

step2：找到最大索引l满足nums[l]>nums[k]——第一遍倒序遍历证明k之后都是降序，同样倒序遍历找到第一个大于nums[k]的元素即为nums[l]

step3：交换nums[l]和nums[k]

step4：翻转nums[k+1:]

class Solution(object):
    def nextPermutation(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        def reverse(nums, start, end):
            while start < end:
                nums[start], nums[end] = nums[end], nums[start]
                start, end = start+1, end-1
            return nums
        
        n = len(nums)
        if n == 1: return  nums

        for k in range(n-2, -1, -1):   
            if nums[k]<nums[k+1]: break

        # k为0的时候可能是定位到0或者结束遍历
        if k or nums[0]<nums[1]: 
            for l in range(n-1, k, -1):
                if nums[l]>nums[k]: break
            nums[k], nums[l] = nums[l], nums[k]
            nums = reverse(nums, k+1, n-1)

        else:
            nums = reverse(nums, 0, n-1)
            
        return nums

287 寻找重复数

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。

因为数字范围在[1,n]之间，即以数字作为下标索引不会出现越界问题；通过这种链接关系构建链表；

以[1,2,3,2]为例：nums[0] = 1  -->  nums[1] = 2  -->  nums[2] = 3  -->  nums[3] = 2 --> nums[2] = 3  （1 -->  2 -->  3 -->  2 -->  3 -->  2 -->  ...）出现了环状结构

寻找环入口：快慢指针     可参考题142

class Solution(object):
    def findDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1: return nums[0]

        fast, slow = nums[nums[0]], nums[0]
        while fast != slow: 
            fast = nums[nums[fast]]
            slow = nums[slow]

        idx1, idx2 = 0, fast
        while idx1 != idx2:
            idx1 = nums[idx1]
            idx2 = nums[idx2]
        
        return idx1

环状问题补充：

1.判断有无环：快慢指针看是否相遇；

2.判断环入口：从快慢指针相遇点和头结点同步同速度出发，相遇的点即为环入口；

3.计算环长度：快慢指针相遇后只移动慢指针，再次相遇时慢指针移动的次数即为环的长度；