刷题 9/19

K个一组翻转链表

链接：题目链接

题目描述

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

解题思路—普通逻辑，hard题

这题的思想和链表两两互换的思想是一致的
但是很多细节处理要注意
我们依旧是创建一个值不存在的dum节点，
然后这是K个一组，所以我们每次将一组子链表翻转的时候要找到当前子链表的头和尾，
找到之后调用一个自定义的翻转节点的函数，将子链表翻转，然后在调用方进行下一组子链表的翻转
特判：有的剩余的子链表长度不满足>=K，直接不处理即可，返回即可

代码实现

class Solution:
    # 翻转一个子链表，并且返回新的头与尾
    def reverse(self,head,tail):
        pre = tail.next
        p = head
        # 子链表的翻转过程
        while pre != tail:
            nex = p.next
            p.next = pre
            pre = p
            p = nex
        return tail,head
    def reverseKGroup(self,head,k):
        hair = ListNode(-1)
        hair.next = head
        pre = hair
        while head:
            tail = pre
            for i in range(k):
                tail = tail.next
                if not tail:
                    return hair.next
            nex = tail.next
            head,tail = self.reverse(head,tail)
            pre.next = head
            tail.next = nex
            pre = tail
            head = tail.next
        return hair.next

左叶子之和

链接：题目链接

题目描述

计算给定二叉树的所有左叶子之和。

示例：

    3
   / \
  9  20
    /  \
   15   7

在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

解题思路----匿名函数，递归

思路比较好理解
就是我们创建一个函数，不管是匿名函数还是普通函数，功能就是判断节点是否是叶子节点
我们递归之前，判断当前节点的左节点是否是叶子节点，是则加上，不是则递归到左节点
判断当前节点的右节点，如果不是叶子节点，递归到右节点去

代码实现

class Solution:
    def sumOfLeftLeaves(self, root: TreeNode) -> int:
        isLeafNode = lambda node: not node.left and not node.right
        def dfs(root):
            res = 0
            if root.left:
                res += root.left.val if isLeafNode(root.left) else dfs(root.left)
            if root.right and not isLeafNode(root.right):
                res += dfs(root.right)
            return res
        return dfs(root) if root else 0
    ## 递归

删除排序数组的重复项

链接：题目链接

题目描述

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。

解题思路—双指针，easy题

一个指针是往后扫的，如果当前指针的元素值！=往后扫的指针的值，
那么将当前指针+1，然后nums[i] = nums[j]即可
最后返回i+1即可，因为长度是从1开始的

代码实现

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        i = 0
        for j in range(1,len(nums)):
            if nums[i] != nums[j]:
                i += 1
                nums[i] = nums[j]
        return i + 1
    # 

移除元素

链接：题目链接

题目描述

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。

解题思路—和删除重复元素那题的思路很像，双指针

这里指针j是从0开始了，只要碰到！=val的，就把j处的值赋给i处，i++
最后返回元素有多少个的时候只需要返回 i 即可

代码实现

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        i = 0
        for j in range(len(nums)):
            if nums[j] != val:
                nums[i] = nums[j]
                i += 1
        return i
# 

实现strStr

链接：题目链接

题目描述

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

示例 1:

输入: haystack = “hello”, needle = “ll”
输出: 2
示例 2:

输入: haystack = “aaaaa”, needle = “bba”
输出: -1

解题思路----普通逻辑

实现代码

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        L,n = len(needle),len(haystack)
        for i in range(n-L+1):
            if haystack[i:i+L] == needle:
                return i
        return -1
#