力扣（2024.06.14）

1. 25——K个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

标签：链表

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        head1 = head
        num = 0
        while head1:
            num = num + 1
            head1 = head1.next
        dummy = res = ListNode()
        while num >= k:
            num = num - k
            start = None
            for i in range(k):
                node1 = head
                node2 = head.next
                res.next = node1
                node1.next = start
                head = node2
                start = res.next
                if i == 0:
                    end = node1
            res = end
        res.next = head
        return dummy.next

2. 26——删除有序数组中的重复项

给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

• 更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
• 返回 k 。

标签：数组，双指针

代码：

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        slow = 0
        fast = 0
        while fast < len(nums):
            if nums[slow] != nums[fast]:
                slow = slow + 1
                nums[slow] = nums[fast]
            fast = fast + 1
        return slow + 1

3. 27——移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

• 更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
• 返回 k。

标签：数组，双指针

代码：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        slow = 0
        fast = 0
        while fast < len(nums):
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow = slow + 1
            fast = fast + 1
        return slow

4. 28——找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

标签：双指针，字符串，字符串匹配，哈希表

代码：

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        haxi = {}
        for idx, i in enumerate(haystack):
            if i not in haxi:
                haxi[i] = [idx]
            else:
                haxi[i].append(idx)
        start = needle[0]
        if start not in haxi:
            return -1
        idxs = haxi[start]
        for i in idxs:
            pointer1 = i
            pointer2 = 0
            while pointer1 < len(haystack) and pointer2 < len(needle):
                if haystack[pointer1] != needle[pointer2]:
                    break
                else:
                    pointer1 = pointer1 + 1
                    pointer2 = pointer2 + 1
            if pointer2 == len(needle):
                return i
        return -1

5. 29——两数相除

给你两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和取余运算。整数除法应该向零截断，也就是截去（truncate）其小数部分。例如，8.345 将被截断为 8 ，-2.7335 将被截断至 -2 。返回被除数 dividend 除以除数 divisor 得到的商。

注意：假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2^31,  2^31 − 1] 。本题中，如果商严格大于 2^31 − 1 ，则返回 2^31 − 1 ；如果商严格小于 -2^31 ，则返回 -2^31 。

标签：位运算，数学（目前不会）

代码：