【Leetcode】EASY题解....ing python

最新推荐文章于 2022-06-26 22:07:05 发布
最新推荐文章于 2022-06-26 22:07:05 发布
阅读量474 收藏 3
点赞数 3
分类专栏： python leetcode 文章标签： leetcode python 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcw1234515/article/details/120024405
版权

文章目录

1. 两数之和[medium]

解题思路

保持每个对应位数的进制carry，对应位置进行运算就行，循环终止条件是l1 or l2 or carry;

代码

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        temp = p = ListNode(None)
        carry = 0 
        sum = 0
        while l1 or l2 or carry:
            sum = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
            p.next = ListNode(sum % 10)
            p = p.next
            carry = sum // 10            
            l1 = l1.next if l1 else None           
            l2 = l2.next if l2 else None
        return temp.next

7. 整数反转[easy]

解题思路

整数翻转转化为字符串翻转，之后再将其转为int类型，判断原始数值和翻转后的数组是否再给定的范围内即可

代码

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        if x > 2**31 - 1 or x < -2**31:
            return 0
        if x < 0 and x >= -2**31:
            x = abs(x)
            x = str(x)
            s = x[::-1]
            s = -int(s)
            if s < -2**31:
                return 0
            return s
        elif x >= 0 and x <= 2**31 - 1:
            x = str(x)
            s = x[::-1]
            s = int(s)
            if s > 2**31 - 1:
                return 0
            else:
                return s

8. 字符串转换整数 (atoi)[M]

解题思路

此处撰写解题思路

代码

class Solution(object):
    def myAtoi(self, s):
        """
        :type s: str
        :rtype: int
        """
        result = int(*re.findall('^[\+\-]?\d+', s.lstrip()))
        if result < -2**31:
            result = -2**31
        elif result > 2**31 - 1:
            result = 2**31 - 1

    
        return result
        #return max(min(int(*re.findall('^[\+\-]?\d+', s.lstrip())), 2**31 - 1), -2**31)

9.回文数

解题思路

将整数变为字符串，如果整数为负数，直接判断不是回文，非负数则将字符串反转，比较反转后的int值和原值是否相等；

代码

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        # 将整数变为字符串
        if x >=0:
            s = str(x)
            # 将字符串反转
            s = s[::-1]
            if int(s) == int(x):
                return True
            else:
                return False
        else:
            return False

12. 整数转罗马数字

解题思路

定义一个列表数组，遍历数组，退出条件是nums = 0
将list 转为str()

  1. result.toString()
  2. result = ‘’.join(result)

代码

class Solution(object):
    def intToRoman(self, num):
        """
        :type num: int
        :rtype: str
        """
        result = []
    # 定义一个字典
        # dict = {'I':1, 'IV':4, 'V':5, 'IX':10, 'X':10, 'XL':40, 'L':50, 'XC':90, 'C':100, 'CD':400, 'D':500, 'CM':900, 'M':1000}
        dict = [
            [1000, 'M'],
            [900, 'CM'],
            [500, 'D'],
            [400, 'CD'],
            [100, 'C'],
            [90, 'XC'],
            [50, 'L'],
            [40, 'XL'],
            [10, 'X'],
            [9, 'IX'],
            [5, 'V'],
            [4, 'IV'],
            [1, 'I'],
        ]


        for value, key in dict:
            while(num >= value):
                result.append(key)
                num -= value
            if num == 0:
                break
                
        result = ''.join(result)
        return result

15. 三数之和

解题思路

双指针+for循环
对 i for 循环，定义j,k 指针，遍历，找到符合条件的列表
对于不符合条件有几种

  1. nums 长度小于3 并且最小值>0
  2. nums[j] == nums[j+1] or nums[k] == nums[k-1]
  3. nums[i] + nums[j] + nums[k] > 0 or nums[i] + nums[j] + nums[k] < 0

代码

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        result = []
        nums.sort()

        for i in range(len(nums)):
            j = i + 1
            k = len(nums) - 1
            if nums[i]>0 or len(nums)<3:
                return result
            if i > 0 and nums[i] == nums[i-1]:
                continue
            while(j < k):
                if nums[i] + nums[j] + nums[k] == 0:
                    result.append([nums[i],nums[j],nums[k]])
                    while(j < k and nums[j] == nums[j+1]):
                        j = j + 1
                    while(j < k and nums[k] == nums[k-1]):
                        k = k - 1
                    j += 1
                    k -= 1

                elif nums[i] + nums[j] + nums[k] < 0:
                    j += 1
                elif nums[i] + nums[j] + nums[k] > 0:
                    k -= 1
        return result

20. 有效的括号[easy]

解题思路

判断如果长度为奇数，直接返回false;
直接将配对括号去掉

代码

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        # 用栈求解
        if len(s)%2 != 0:
            return False
        while '()' in s or '[]' in s or '{}' in s:
            s = s.replace('[]','').replace('()','').replace('{}','')
        return True if s == '' else False

21. 合并两个有序链表

解题思路

两个指针，一个头指针，一个移动指针，变换的都是移动指针，最后返回头指针的next;
cur.next = l1 if l1 is not None else l2

代码

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        cur = ListNode()
        temp = cur # 保存头指针，移动的是cur指针
        while l1 and l2:
            if l1.val <= l2.val:
                cur.next = l1
                l1 = l1.next
            elif l1.val > l2.val:
                cur.next = l2
                l2 = l2.next
            cur = cur.next
        if l1 is not None:
            cur.next = l1
        elif l2 is not None:
            cur.next = l2
        return temp.next

27. 移除元素[Easy]

解题思路

计算除去val之后元素的个数，之后对nums进行排序
image.png

代码

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        count = nums.count(val)
        l = len(nums) - count
        j = 0
        for i in range(len(nums)):
            if nums[i] != val:
                nums[j] = nums[i]
                j += 1
        return l

23. 合并K个升序链表

思路

  1. 将list每个list提取出来合并排序，
  2. 重新将list直接串成链表

代码




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

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        result = []
        for i in lists:
            while i: 
                result.append(i.val)
                i = i.next
        first = cur = ListNode(-1)
        result.sort()
        for j in result:
            cur.next = ListNode(j)
            cur = cur.next
        return first.next

26. 删除有序数组中的重复项[easy]

题目

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/

解题思路

如果后一个元素与前一个元素不相等的话，按顺序将元素zai nums数组中进行组合

代码

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        j = 1
        for i in range(1,len(nums)):
            if nums[i] != nums[i-1]:
                nums[j] = nums[i]
                j+=1
        return j

53. 最大子序和

解题思路

  1. nums 长度为1 直接返回
  2. 先将max置为最小值，如果每一次加上下一个数sum值能变大，变换max值

代码

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        count = 0
        ans = []
        max = -10e5
        if len(nums) == 1:
            return nums[0]


        sum = 0
        for i in range(len(nums)):
            
            sum = sum + nums[i]
            if sum >= max:
                max = sum 
            if sum <=0:
                sum = 0
        return max

58. 最后一个单词的长度

解题思路

代码

class Solution(object):
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        s = s.strip(" ")
        l = s.replace(",", " ")
        ans = l.split(" ")
        result = ans[-1]
        count = 0
        count = len(result)
        return count

67. 二进制求和

解题思路

  1. 将二进制转为十进制进行运算
  2. 将结果转为二进制（bin()）
  3. 去除表示进制的前两个字符
    image.png

代码

class Solution(object):
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        # 求解二进制，转为十进制，再转为二进制
        t1 = int(a, 2)
        t2 = int(b, 2)
        sum = t1 + t2
        ans = bin(sum)
        return ans[2:] # 去除进制前缀

88. 合并两个有序数组

题目

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

解题思路

  1. 直接将 nums2 接在 nums1 后面
  2. 对 nums1 进行排序

代码

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        j = 0
        for i in range(m,m+n):
            nums1[i] = nums2[j]
            j = j + 1
        nums1.sort()
        return nums1

110. 平衡二叉树

题目

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

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

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

解题思路

  1. 求出左右子树的最大高度
  2. 判断树是否为空
  3. 判断是否左右子树都为平衡子树

代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isBalanced(self, root):
        def height(root):
            if not root:
                return 0
            return max(height(root.left), height(root.right)) + 1

        if not root:
            return True
        return abs(height(root.left) - height(root.right)) <= 1 and self.isBalanced(root.left) and self.isBalanced(root.right)

101. 对称二叉树

题目

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

解题思路

  1. 思考
  2. 利用递归
  3. 给两个根节点，从对称的方向向下递归，判断对称节点是否对称
  4. 返回相应的bool

代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:

        return self.isequeal(root,root)

    def isequeal(self , p: TreeNode, q:TreeNode)->bool:
        if (p is None and q is None):
            return True
        if (p is None or q is None):
            return False
        if (p.val == q.val): # 只有对称才进行下一步递归
            return self.isequeal(p.left, q.right) and self.isequeal(p.right, q.left)

        else: # 不对称直接return 
            return False

111. 二叉树的最小深度

题目

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

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

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

解题思路

  1. 递归，确定递归结束条件：数为空时：return 0 else 1
  2. 判断左右子树
  3. 全部非空由之前深度加上当前1
  4. 左右子树部分非空

代码


# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """

        if root is None: # 树为空
            return 0 
        if root.left and root.right: # 左右子树都非空
            return 1 + min(self.minDepth(root.left), self.minDepth(root.right))
        if root.left: # 左子树非空
            return 1 + self.minDepth(root.left)
        if root.right: # 右子树非空
            return 1 + self.minDepth(root.right)
        else:
            return 1

剑指Offer

剑指 Offer 03. 数组中重复的数字

解题思路

找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3

排序比较

代码

from collections import Counter
class Solution(object):
    def findRepeatNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums.sort()
        for i in range(len(nums)):
            if nums[i]==nums[i+1]:
                return nums[i]
Jucway
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Leetcode（easy）解题思路
一江明澈的水的专栏
11-19 336
1. 两数之和 用字典构造哈希表dict，key是给定数组nums的成员，value为nums成员的索引。然后在dict中依次查找是否有target-nums[i] 学习语法：dict.has_key(target-nums[i]) python3改为 in 7.整数反转 取绝对值，再模10取余，构造新的反转整数，再判断是否在int32范围内-2147483648 到2147483647之...
LeetCode 热题 HOT 100题解 (easy级别)
最新发布
m0_61068496的博客
04-11 944
现阶段较热门是React、Vue两大框架，两者工作原理上存在共通点，也存在一些不同点，对于校招来说，不需要两个框架都学得特别熟，一般面试官会针对你简历中写的框架进行提问。现阶段较热门是React、Vue两大框架，两者工作原理上存在共通点，也存在一些不同点，对于校招来说，不需要两个框架都学得特别熟，一般面试官会针对你简历中写的框架进行提问。再遍历数组的第一个字符串，用字符串中的每一个字符和数组中的每一项的对应的该字符串下标相比，不同则跳出循环，两两找出公共前缀，最终结果即为最长公共前缀的长度 j。
我的算法笔记 | leetCode easy题感受
博学之,审问之,慎思之,明辨之,笃行之
06-26 307
本周刷了30道题LeetCode题。 选题的标准就是从Top榜里选easy，高频。都是easy题，也有可能是之前的有些题自己在很早之前也见过，这次刷起来极为顺手。 虽然都是easy题，但感觉还是挺欣慰的。觉得从4月底到现在死磕的算法看到了一些成效。毕竟再简单的题，之前也是要费尽心思的看半天，然后对对答案再调试半天才能做出来。现在对大部分常见的简单题也可以上手就做了。逐渐对easy题有了一些掌控感。还有4天就到我的目标了。还有20道题。按照这个进度问题不大。算法如果收尾，还挺遥远的。毕竟还有动态规划和贪心还没
Python 学习 （Leetcode 算法题解【easy部分 技巧总结】）
Hans__Yang的博客
08-17 2299
使用python进行算法题目的练习，对python有了一个基本的了解，在此把这段时间以来学习到的在算法和编程方面的一点经验和技巧记录在此。在日后逐步深入学习的过程中，在慢慢对此进行丰富。如果可能，在完成一定量的算法题目之后，在把这些零碎的经验和技巧综合起来，作为对算法和编程部分的一个整体的总结。
LeetCode(Python实现)——Easy部分【Day8】
初一的博客
05-12 232
LeetCode(Python实现)——Easy部分【Day8】
Leetcode刷题汇总（Easy篇） -- Python
Chris_zhangrx的博客
01-17 4287
Easy篇 Array 专题 561 Array Partition I | 66.5% Easy 566 Reshape the Matrix 58.0% Easy 485 Max Consecutive Ones 53.9% Easy 695 Max Area
LeetCode刷题题解.rar
10-31
《LeetCode刷题题解》是一份集合了多个资源的压缩包，主要目的是帮助学习者在准备面试或者提升编程技能时，通过解决LeetCode上的问题来加深对算法和数据结构的理解。LeetCode是一个在线的编程挑战平台，它包含了各种...
leetcode部分题解.rar_java_leet 程序员_leetcode
09-21
《LeetCode部分题解——Java程序员的进阶之路》 在程序员的世界里，LeetCode是一个不可或缺的刷题平台，尤其对于Java程序员来说，它提供了大量的编程挑战，旨在提升算法理解、数据结构掌握以及问题解决能力。这个名...
python-leetcode常用函数.docx
06-11
python leetcode常用函数 Python LeetCode常用函数 LeetCode是一个非常流行的算法题库，许多程序员都会在这里刷题来提高自己的算法能力。Python是一种非常流行的编程语言，也是许多程序员喜欢使用的语言之一。在这篇...
Leetcode 题解.pdf
09-13
Leetcode 题解 Leetcode 题解.pdf 文档提供了多个算法思想和 Leetcode 题目的解决方案，涵盖了双指针、数组遍历、字符串处理等多个方面。下面是对文档中所涉及的知识点的详细讲解： 一、双指针思想 双指针是一种...
python-leetcode面试题解之第31题下一个排列-python题解.zip
03-12
"python-leetcode面试题解之第31题下一个排列-python题解.zip" 这个标题表明这是一个关于Python编程语言的资源包，专门针对LeetCode平台上的第31题“下一个排列”的解决方案。LeetCode是一个知名的在线编程挑战平台...
leetcode分类-Easy_LeetCode:科学刷LeetCode，分类刷题，效果更佳
06-30
leetcode 分类 Easy_LeetCode 科学刷LeetCode题 1. 题目分类 2. 贪心算法 3. 玩转双指针 4. 二分查找 5. 排序算法 6. 深度优先搜索，广度优先搜索 7. 动态规划 8. 分治法 9. 位运算 10. 妙用数据结构 11. 链表 12. 树 13. 图 14.并查集 参考
leetcode121、122--买股票的最佳时机I、II
never_say_never7的博客
04-21 131
题目I描述 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。 注意：你不能在买入股票前卖出股票。 示例 1: 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 ...
Leetcode--easy系列5
所思 所学 我写 我得
06-24 563
#83 Remove Duplicates from Sorted List Given a sorted linked list, delete all duplicates such that each element appear only once. For example, Given 1->1->2, return 1->2. Given 1->1->2->3->3
LeetCode的Easy题目
你是谁笔下的少年，在风中辗转成歌
11-07 1034
LeetCode的Easy题目标签（空格分隔）： 算法题，代码网上都有，就只贴一下github了。这里主要总结一下从题目中学到的，如何举一反三一、Two Sum好像很简单，上来就两个粗暴循环了。也想到时间复杂度是个问题，但是并没有想太多，看到discuss里的答案，才真正发现题目不难，想个好的方法是比较重要的。题目总结 类似的，输入输出的元素都是一个列表中的，重点考虑取出另存放，然后比较的操作，可以
Leetcode--easy系列1
所思 所学 我写 我得
06-22 1241
#6 ZigZag Conversion The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
leetCode解题思路（easy篇）
TRUE_LOVE1314的专栏
09-24 515
1. Two Sum 题目要求：给定一个Integer nums数组 和一个 int target 返回数组中两数之和等于target的元素的下标。 解题思路： 1.枚举 两层for循环 On2 2.先排序 额外占用n空间存储nums副本，两个ij哨兵从排序后的数组两端搜索直到找到符合的值，之后确定值在远数组中的下标 public int[] twoSum(int[] nums, in...
LeetCode: 继续easy题12
Wayne2019的博客
03-21 316
Subtree of Another Tree class Solution { public: bool isSame(TreeNode* s, TreeNode* t){ if(!s &amp;&amp; !t) return true; if(s &amp;&amp; t) return (s-&g...
leetcode 001.两数之和
学无止境,勤则可达；志存高远,恒亦能成！
04-19 212
方法一：暴力枚举 思路及算法 最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。 当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。 代码 class Solution { public int[] twoSum(int[] nums, int target) { i..
力扣(LeetCode)2731. 移动机器人
10-18
好的，关于力扣2731题，这是一道模拟题，题目描述如下： 机器人在一个无限大小的 XY 网格平面上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令 commands ： - -2 ：向左转 90 度 - -1 ：向右转 90 度 - 1 <= x <= 9 ：向前移动 x 个单位长度 在网格上有一些格子被视为障碍物 obstacles 。第 i 个障碍物位于网格点 obstacles[i] = (xi, yi) 上。 机器人无法走到障碍物上，它将会停留在障碍物的前一个网格方块上，但仍然可以继续尝试进行该路线的其余部分。 返回从原点到机器人所有经过的路径点（坐标为整数）。答案保证在 10^9 以内。 示例 1： 输入: commands = [4,-1,3], obstacles = [] 输出: [[0,0],[0,1],[0,2],[0,3]] 示例 2： 输入: commands = [4,-1,4,-2,4], obstacles = [[2,4]] 输出: [[0,0],[0,1],[0,2],[1,2],[2,2],[2,3],[2,4]] 解题思路： 我们可以用一个变量来表示当前机器人的朝向，然后根据不同的命令进行模拟即可。需要注意的是，如果机器人前方有障碍物，那么它只能停留在障碍物前面一格，不能穿过障碍物。 代码如下：

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jucway

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值