【leetcode】python算法题库——简单难度【2】

最新推荐文章于 2023-06-13 13:37:16 发布
最新推荐文章于 2023-06-13 13:37:16 发布
阅读量429 收藏 5
点赞数
分类专栏： 算法刷题/竞赛 文章标签： leetcode python 算法题库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m511655654/article/details/82587558
版权

66. 加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

代码：

class Solution:
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        digits[-1] = digits[-1] + 1
        return digits

if __name__ == '__main__':
    digits = [1,2,3]
    out = Solution()
    output = out.plusOne(digits)
    print(output)

67. 二进制求和

给定两个二进制字符串，返回他们的和（用二进制表示）。

输入为非空字符串且只包含数字 1 和 0。

示例 1:

输入: a = "11", b = "1"
输出: "100"

示例 2:

输入: a = "1010", b = "1011"
输出: "10101"

代码：

class Solution:
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        intNum=int(a,2)+int(b,2)#2进制转换成10进制，再求和
        return bin(intNum)[2:]#10进制转换成2进制时前两位为0b，需要去除

if __name__ == '__main__':
    a = "1010"
    b = "1011"
    out = Solution()
    output = out.addBinary(a, b)
    print(output)

69. x 的平方根

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

代码：

class Solution:
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        left = 0
        right = x
        while left < right:
            mid = int((left + right) / 2)
            if x < mid ** 2:
                right = mid
            else:
                left = mid + 1
        if left > 1:
            return left - 1
        else:
            return left

if __name__ == '__main__':
    x = 8
    out = Solution()
    output = out.mySqrt(x)
    print(output)

70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

代码：

class Solution:
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        # 从第三个开始，爬楼梯的方法是前面两个的和（参考斐波那契数列）
        count = [1, 2]
        for i in range(2, n):
            # 利用列表存储当前计算结果，避免重复计算
            count.append(count[i - 1] + count[i - 2])
        return count[n - 1]

if __name__ == '__main__':
    n = 3
    out = Solution()
    output = out.climbStairs(n)
    print(output)

83. 删除排序链表中的重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2
输出: 1->2

示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

代码：

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

class Solution:
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None or head.next == None:
            return head
        p =head
        while p:
            while p.next and p.val == p.next.val:
                p.next = p.next.next
            p = p.next
        return head

88. 合并两个有序数组

给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

  • 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
  • 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

输出: [1,2,2,3,5,6]

代码：

class Solution:
    def merge1(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        nums1[m:m + n] = nums2[:n]
        nums1.sort()
        return nums1

    def merge2(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        while m > 0 and n > 0:
            if nums1[m-1] > nums2[n-1]:
                nums1[m+n-1] = nums1[m-1]
                m -= 1
            else:
                nums1[m+n-1] = nums2[n-1]
        if n > 0 :
            nums1[:n] = nums2[:n]
        return nums1

if __name__ == '__main__':
    nums1 = [1, 2, 3, 0, 0, 0]
    m = 3
    nums2 = [2, 5, 6]
    n = 3
    out = Solution()
    output = out.merge1( nums1, m, nums2, n)
    print(output)

100. 相同的树

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:       1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

输出: true

示例 2:

输入:      1          1
          /           \
         2             2

        [1,2],     [1,null,2]

输出: false

示例 3:

输入:       1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

输出: false

代码：

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

class Solution:
    def isSameTree(self, p, q):
        """
        :type p: TreeNode
        :type q: TreeNode
        :rtype: bool
        """
        if not p and not q:#两二叉树皆为空，递归边界，两者皆为空返回真
            return True
        if p and q and p.val==q.val:
            l=self.isSameTree(p.left,q.left)#递归，每次重新从函数入口处进行，每次进行递归边界判断
            r=self.isSameTree(p.right,q.right)
            return l and r#and操作，需要l与r皆为true时，才返回真。只用最后一次递归边界return值
        else:
            return False

101. 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [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

说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

代码：

class Solution:
    def isSymmetrical(self, pRoot):
        if not pRoot:
            return True
        return self.recursiveTree(pRoot.left, pRoot.right)

    def recursiveTree(self, left, right):
        if not left and not right:
            return True
        if not left or not right:
            return False
        if left.val != right.val:
            return False
        return self.recursiveTree(left.left, right.right) and self.recursiveTree(left.right, right.left)

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

代码：

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

class Solution:
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        leftDepth = self.maxDepth(root.left) + 1
        rightDepth = self.maxDepth(root.right) + 1
        return max(leftDepth, rightDepth)

107. 二叉树的层次遍历 II

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

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

    3
   / \
  9  20
    /  \
   15   7

返回其自底向上的层次遍历为：

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

代码：

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

class Solution:
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

        #bfs广度优先搜索，不熟悉可以网上参考bfs代码
        if not root:
            return []#为空则返回空列表
        queue = [root]#使用列表实现队列的功能，首先存储root
        res = []
        while queue:#当queue不为空时
            nodes = []#存节点，每次循环前置空，每次只装一部分
            node_values = []#存节点的值
            for node in queue:
                if node.left:
                    nodes.append(node.left)#将左子树装入队列中
                if node.right:
                    nodes.append(node.right)
                node_values += [node.val]#因为每次循环node_values都会置空，所以最终结果保存在res里，node_values只是一小部分结果
            res = [node_values] + res#实现从底到顶，node_values放前面.
            queue = nodes#将新添加的节点重新赋值给queue

        return res

108. 将有序数组转换为二叉搜索树

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

代码：

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

class Solution:
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if not nums:
            return None
        mid = len(nums)//2  #//	取整除 - 返回商的整数部分（向下取整）
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        return root

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

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

    3
   / \
  9  20
    /  \
   15   7

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4

返回 false 。

思路：按照求树的最大深度去做，只是中间加一个判断，判断左子树的最大深度和右子树的最大深度之差是否大于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 isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        left = self.TreeDepth(root.left)
        right = self.TreeDepth(root.right)
        if abs(left - right) > 1:
            return False
        return self.isBalanced(root.left) and self.isBalanced(root.right)
        
        
    def TreeDepth(self, root):
        if not root:
            return 0
        left = self.TreeDepth(root.left)
        right = self.TreeDepth(root.right)
        return max(left, right) + 1

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度  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 minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        leftDepth = self.minDepth(root.left)
        rightDepth = self.minDepth(root.right)
        if not root.left or not root.right:
            return max(leftDepth, rightDepth) + 1
        return min(leftDepth, rightDepth) + 1

112. 路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例: 
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->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 hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        if not root :
            return False
        sum -= root.val #总和减去根节点值
        if sum == 0 and not root.left and not root.right:
            return True
        return self.hasPathSum(root.left, sum) or self.hasPathSum(root.right, sum)

 

保护我方鲁班七号
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode题库-LeetCode_Python:LeetCode算法题Python实现
06-29
leetcode题库 LeetCode_Python LeetCode算法题Python实现 Update 本库不再更新，移步至新库LeetCode算法题Java实现持续更新
leetcode python3 简单难度（答案持续更新）
yyy430的博客
04-26 4026
leetcode中国官方网站-题库https://leetcode-cn.com/problemset/all/leetcode官网-题库https://leetcode.com/problemset/all/参考资料https://blog.csdn.net/minione_2016/article/details/788551240001.Two_Sum答案class Solution(obj...
python案例——算法入门10例
weixin_43318393的博客
09-03 2634
python最常用的十个案例详解，迭代法案例，考试常考案例，算法入门，上手编程。
二进制求和（给定两个二进制字符串，返回他们的和（用二进制表示））
be_gin_ner的博客
02-28 2358
给定两个二进制字符串，返回他们的和（用二进制表示）。 输入为非空字符串且只包含数字 1 和 0。 示例 1: 输入: a = "11", b = "1" 输出: "100" 示例 2: 输入: a = "1010", b = "1011" 输出: "10101" 解题思路：将两个字符串从后往前依次相加存入动态字符串中。每次相加有四种情况，0 ，1，2, 3（有进位的情况下才有可能），
给定两个二进制字符串，返回他们的和（用二进制表示）。 输入为非空字符串且只包含数字 1 和 0。
qq_41152046的博客
02-23 2283
1.给定两个二进制字符串，返回他们的和（用二进制表示）。 输入为非空字符串且只包含数字 1 和 0。 示例 1: 输入: a = “11”, b = “1” 输出: “100” 示例 2: 输入: a = “1010”, b = “1011” 输出: “10101” 2.代码展示 char* addBinary(char* a, char* b) { int i = strlen(a);...
LeetCode题库第67题二进制求和
qq_53818001的博客
04-23 1695
题目描述:给你两个二进制字符串，返回它们的和（用二进制表示）。输入为 非空 字符串且只包含数字1和0。 题解思路: 把二进制字符串转换成数组这样便于运算 把数组元素进行倒转,最后再把运算结果倒转一下;因为二进制运算是从右到左运算 对两个数组进行循环,把对应位置的数字相加,再定义一个空数组,若相加大于等于2时,则在数组中加入相加结果减去2的值,并在下一次循环时把结果加1;若小于2时则在数组中加入相加的结果 再把数组倒转返回结果就可以了 下面实战开始: 定义函数,参数为需传入的两个字符串...
LeetCode 算法题库【136】——只出现一次的数字
12-21
首先看到这题，我们需要找到那个唯一的只出现一次的数字，而其他的数字都是只出现了两次，那么我们如果一个一个的去数组里找是否有重复的，这样时间复杂度会很大，所以我们要想如何更加简单的找出唯一的只出现一次的...
python【力扣LeetCode算法题库】19-删除链表的倒数第N个节点
01-21
给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明： 给定的 n 保证是有效的。 进阶： 你能尝试使用一趟扫描实现吗？ # Definition for singly-linked list. # class ...
python【力扣LeetCode算法题库】365- 水壶问题（裴蜀等式）
12-21
水壶问题 有两个容量分别为 x升 和 y升 的水壶以及无限多的水。请判断能否通过使用这两个水壶，从而可以得到...输入: x = 2, y = 6, z = 5 输出: False 若a,b是整数,且gcd(a,b)=d，那么对于任意的整数x,y,ax+by都一定
LeetCode 算法题库学习（14）
01-20
最长公共前缀 题目描述： 解题思路： 第一种：这个思路比较容易想到，我们可以发现，我们需要找这些字符串的相同前缀，那么这个前缀所含有字符的最大数目取决于所给字符串集中最小的那个字符串。...
python算法趣味题目
07-10
python算法趣味题目.doc
【LeetCode 67】二个进制数求和
mitongxue的博客
12-24 3847
题目描述 给你两个二进制字符串，返回它们的和（用二进制表示）。 输入为 非空 字符串且只包含数字 1 和 0。 示例 1: 输入: a = “11”, b = “1” 输出: “100” 示例 2: 输入: a = “1010”, b = “1011” 输出: “10101” 提示： 每个字符串仅由字符 '0' 或 '1' 组成。 1 <= a.length, b.length <= 10^4 字符串如果不是 "0" ，就都不含前导零。 解题思路    
值得收藏的25道Python练手题（附详细答案）
热门推荐
m0_59235245的博客
06-13 1万+
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。（全套教程文末领取哈）
给定两个二进制字符串，返回他们的和（用二进制表示）。
changaspl
11-02 2805
给定两个二进制字符串，返回他们的和（用二进制表示）。 输入为非空字符串且只包含数字 1 和 0。 示例 1: 输入: a = "11", b = "1" 输出: "100" 示例 2: 输入: a = "1010", b = "1011" 输出: "10101" AC代码 class Solution { public String addBinary(St
常见算法题Python
zpp15603669517的博客
10-23 611
滑动窗口1
100 道 Python 算法题及答案集合，拿去刷！
JAVAmonster12的博客
05-20 3064
实现一个算法：识别一个字符串中，是否包含唯一的字符。
25道Python练手题（附详细答案），赶紧收藏！python入门
Python_9521的博客
06-02 1万+
迭代之后发现第二个分隔符，是不是还有一个分隔符的索引，这个时候我们继续向字符串进行切片，切片的开始位置是你的 i 这个位置的指针，结束的位置是第二个 - 的指针，那遵循左闭右开，所以我们 is 这个单词，也可以添加进列表。就这样一直到最后呢，当我们去迭代到最后一个字符 n 的时候，发现后面是没有横杆分隔符了，这个时候我们需要进行处理一下，需要进行去判断一下，如果我们迭代到的字符是最后一个字符，那么我们进行切片的时候，就应该从哪个地方切呢？“ 请你写出：小明的较小的妹妹的年龄。“我年龄的立方是个 4 位数。
python面试问题总结
ZH01234565的博客
09-28 220
0.什么是Python?使用Python有什么好处?(这个问题是最常见的开头问题，是最基础也是最重要的!) 答案:下面是一些关键点: Python是一种解释型语言。这就是说，与C语言和C的衍生语言不同，Python代码在运行之前不需要编译。其他解释型语言还包括PHP和Ruby。 Python是动态类型语言，指的是你在声明变量时，不需要说明变量的类型。你可以直接编写类似x=111和x=“I’m a ...
Python 思维锻炼
weixin_34318956的博客
12-24 3373
2019独角兽企业重金招聘Python工程师标准>>> ...
leetcode pdf python
最新发布
08-02
LeetCode是一个在线的编程题库，提供了各种算法和数据结构的练习题目，用于帮助开发者提升编程能力和解决实际问题。 在LeetCode上，我们可以使用Python编写算法题的解决方案。Python是一种简洁且易于学习的编程语言...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值