力扣hot100题解（python版96-100题）

96、只出现一次的数字

给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

示例 1 ：

输入：nums = [2,2,1]
输出：1

示例 2 ：

输入：nums = [4,1,2,1,2]
输出：4

示例 3 ：

输入：nums = [1]
输出：1

提示：

• 1 <= nums.length <= 3 * 104
• -3 * 104 <= nums[i] <= 3 * 104
• 除了某个元素只出现一次以外，其余每个元素均出现两次。

思路解答：

1、任何数和 0 做异或运算，结果仍然是原来的数：a ⊕ 0 = a

2、任何数和其自身做异或运算，结果为 0：a ⊕ a = 0

3、异或运算满足交换律和结合律：a ⊕ b ⊕ a = (a ⊕ a) ⊕ b = 0 ⊕ b = b

因此，对数组中的所有元素进行异或运算，最终的结果就是只出现一次的元素。

def singleNumber(nums: list[int]) -> int:
    result = 0
    for num in nums:
        result ^= num
    return result

97、多数元素

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

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

示例 1：

输入：nums = [3,2,3]
输出：3

示例 2：

输入：nums = [2,2,1,1,1,2,2]
输出：2

提示：

• n == nums.length
• 1 <= n <= 5 * 104
• -109 <= nums[i] <= 109

**进阶：**尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。

思路解答：

假设数组的第一个元素是多数元素，然后遍历数组，对于每个元素进行投票，如果遇到相同的元素就加一票，否则减一票。当票数减为0时，就将当前元素设为候选多数元素。

由于多数元素出现的次数大于n/2，所以最终剩下的候选多数元素一定是多数元素。

def majorityElement(nums: list[int]) -> int:
    candidate = None
    count = 0

    for num in nums:
        if count == 0:
            candidate = num
        count += 1 if num == candidate else -1

    return candidate

98、颜色分类

给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

必须在不使用库内置的 sort 函数的情况下解决这个问题。

示例 1：

输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]

示例 2：

输入：nums = [2,0,1]
输出：[0,1,2]

提示：

• n == nums.length
• 1 <= n <= 300
• nums[i] 为 0、1 或 2

进阶：

• 你能想出一个仅使用常数空间的一趟扫描算法吗？

思路解答：

1、使用三个指针：left、right 和 curr，其中left指向当前已经排好的 0 的右边界，right指向当前已经排好的 2 的左边界，curr用于遍历数组。

2、遍历数组，若nums[curr]等于0，则与nums[left]交换元素，然后curr和left指针右移；若nums[curr]等于2，则与nums[right]交换元素，然后right指针左移；若nums[curr]等于1，则curr指针右移。

3、遍历结束后，数组就会按照红、白、蓝的顺序排列。

def sortColors(nums: list[int]) -> None:
    left, right, curr = 0, len(nums) - 1, 0

    while curr <= right:
        if nums[curr] == 0:
            nums[curr], nums[left] = nums[left], nums[curr]
            curr += 1
            left += 1
        elif nums[curr] == 2:
            nums[curr], nums[right] = nums[right], nums[curr]
            right -= 1
        else:
            curr += 1

99、下一个排列

整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。

• 例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。

整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

• 例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。
• 类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
• 而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。

给你一个整数数组 nums ，找出 nums 的下一个排列。

必须 原地 修改，只允许使用额外常数空间。

示例 1：

输入：nums = [1,2,3]
输出：[1,3,2]

示例 2：

输入：nums = [3,2,1]
输出：[1,2,3]

示例 3：

输入：nums = [1,1,5]
输出：[1,5,1]

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 100

思路解答：

1. 从右向左遍历数组，找到第一个降序的位置i，即找到第一个满足nums[i] < nums[i+1]的位置i。
2. 在位置i的右侧找到大于nums[i]的最小元素，将其与位置i的元素交换。
3. 将位置i右侧的元素按升序排列，以得到下一个排列。

def nextPermutation(nums: list[int]) -> None:

   n = len(nums)
   i = n - 2
   
   # 找到第一个降序的位置i
   while i >= 0 and nums[i] >= nums[i + 1]:
       i -= 1
   
   if i >= 0:
       j = n - 1
       # 找到大于nums[i]的最小元素
       while nums[j] <= nums[i]:
           j -= 1
       nums[i], nums[j] = nums[j], nums[i]
   
   # 将位置i右侧的元素按升序排列
   left, right = i + 1, n - 1
   while left < right:
       nums[left], nums[right] = nums[right], nums[left]
       left += 1
       right -= 1

100、寻找重复数

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。

你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。

示例 1：

输入：nums = [1,3,4,2,2]
输出：2

示例 2：

输入：nums = [3,1,3,4,2]
输出：3

示例 3 :

输入：nums = [3,3,3,3,3]
输出：3

提示：

• 1 <= n <= 105
• nums.length == n + 1
• 1 <= nums[i] <= n
• nums 中 只有一个整数 出现 两次或多次 ，其余整数均只出现 一次

进阶：

• 如何证明 nums 中至少存在一个重复的数字?
• 你可以设计一个线性级时间复杂度 O(n) 的解决方案吗？

思路解答：

1. 定义快慢指针，快指针每次移动两步，慢指针每次移动一步。
2. 首先，让快慢指针相遇，相遇点一定在环内。
3. 然后，将快指针移到起点，快慢指针以相同速度移动，再次相遇的地方就是环的入口点。

def  findDuplicate(nums: list[int]) -> int:
    slow = nums[0]
    fast = nums[0]

    while True:
        slow = nums[slow]
        fast = nums[nums[fast]]

        if slow == fast:
            break

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

    return slow