python leetcode打卡记录（四）(坚持就是胜利1)_坚持就是胜利怎么编写程序-CSDN博客

本文链接：https://blog.csdn.net/m0_51734025/article/details/121306377

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码1

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head ==None or head.next==None:
            return head
        res=self.reverseList(head.next)
        head.next.next=head
        head.next=None
        return res

代码2

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre=None
        cur=head
        while cur:
            tmp=cur.next
            cur.next=pre
            pre=cur
            cur=tmp
        return pre

二、合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        head=ListNode(-1)
        cur=head

        while l1 and l2:
            if l1.val<l2.val:
                cur.next=l1
                l1=l1.next
            else:
                cur.next=l2
                l2=l2.next
            cur=cur.next

        cur.next=l1 if l1 is not None else l2
        return head.next

三、二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：

     4
   /   \
  2     7
/ \   / \
1   3 6   9
镜像输出：

     4
   /   \
  7     2
/ \   / \
9   6 3   1

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码1

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        tmp=root.left
        root.left=self.mirrorTree(root.right)
        root.right=self.mirrorTree(tmp)
        return root

代码2

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        stack=[root]
        while stack:
            node=stack.pop()
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
            node.left,node.right=node.right,node.left
        return root

四、对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        def recur(L,R):
            if not L and not R:
                return True
            if not L or not R or L.val != R.val:
                return False
            return recur(L.left,R.right) and recur(L.right,R.left)
        return recur(root.left,root.right) if root else True

五、包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.min(); --> 返回 -2.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码1

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.l_A=[]
        self.l_B=[]


    def push(self, x: int) -> None:
        self.l_A.append(x)
        if not self.l_B or self.l_B[-1]>=x:
            self.l_B.append(x)



    def pop(self) -> None:
        if self.l_A.pop()==self.l_B[-1]:
            self.l_B.pop()


    def top(self) -> int:
        return self.l_A[-1]


    def min(self) -> int:
        return self.l_B[-1]

代码2

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack1 = list()
        self.stack2 = list()


    def push(self, x: int) -> None:
        self.stack1.append(x)
        if not self.stack2 or self.stack2[-1]>=x:
            self.stack2.append(x)


    def pop(self) -> None:
        if self.stack1.pop() == self.stack2[-1]:
            self.stack2.pop()


    def top(self) -> int:
        return self.stack1[-1]



    def min(self) -> int:
        return self.stack2[-1]

六、从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

例如:
给定二叉树: [3,9,20,null,null,15,7],

3
/ \
9 20
/ \
15 7
返回：

[3,9,20,15,7]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: 
            return []
        l=[]
        l.append(root)
        l_new=[]
        while len(l)>0:
            root=l.pop(0)
            l_new.append(root.val)
            if root.left:
                l.append(root.left)
            if root.right:
                l.append(root.right)

        return l_new

七、从上到下打印二叉树 II

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例如:
给定二叉树: [3,9,20,null,null,15,7],

3
/ \
9 20
/ \
15 7
返回其层次遍历结果：

[
[3],
[9,20],
[15,7]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: 
            return []
        l=[]
        l.append(root)
        l_new=[]
        while len(l)>0:
            tmp=[]
            for _ in range(len(l)):
                root=l.pop(0)
                tmp.append(root.val)
                if root.left:
                    l.append(root.left)
                if root.right:
                    l.append(root.right)
            l_new.append(tmp)
        return l_new

八、连续子数组的最大和

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

要求时间复杂度为O(n)。

示例1:

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        temp=nums[0]
        max_=temp
        for i in range(1,len(nums)):
            if temp>0:
                temp+=nums[i]
                max_=max(max_,temp)
                
            else:
                temp=nums[i]
                max_=max(max_,temp)
        return max_

九、礼物的最大价值

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

示例 1:

输入:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 12
解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码1

class Solution:
    """
    状态定义：dp[i][j] (i,j)的最大价值
    状态转移方程：dp[i][j] = max(dp[i][j-1], dp[i-1][j]) + grid[i][j]
    """
    def maxValue(self, grid: List[List[int]]) -> int:
        x,y=len(grid),len(grid[0])
        mgrid=[[0]*y for _ in range(x)]
        mgrid[0][0]=grid[0][0]
        for i in range(1,x):
            mgrid[i][0]=mgrid[i-1][0]+grid[i][0]
        
        for j in range(1,y):
            mgrid[0][j]=mgrid[0][j-1]+grid[0][j]

        for i in range(1,x):
            for j in range(1,y):
                mgrid[i][j]=max(mgrid[i-1][j],mgrid[i][j-1])+grid[i][j]
        return mgrid[-1][-1]

代码2

class Solution:
    def maxValue(self, grid: List[List[int]]) -> int:
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if i==0 and j==0:
                    continue
                elif i==0:
                    grid[i][j]+=grid[i][j-1]
                elif j==0:
                    grid[i][j]+=grid[i-1][j]
                else:
                    grid[i][j]+=max(grid[i-1][j],grid[i][j-1])
        return grid[-1][-1]

十、第一个只出现一次的字符

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。

示例 1:

输入：s = "abaccdeff"
输出：'b'
示例 2:

输入：s = ""
输出：' '

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码1

class Solution:
    def firstUniqChar(self, s: str) -> str:
        if not s:
            return ' '
        l=[]
        l_more=set()
        for i in s:
            if i not in l_more:
                if i in l:
                    l.remove(i)
                    l_more.add(i)
                else:
                    l.append(i)
        if len(l)==0:
            return " "
        return l[0]

代码2

class Solution:
    def firstUniqChar(self, s: str) -> str:
        if len(s)==0:
            return ' '
        l={}
        for i in s:
            if i not in l:
                l[i]=[i,0]
            else:
                l[i][1]+=1
        for i in s:
            if l[i][1]==0:
                return l[i][0]

        else:
            return " "