LeetCode题目解答

最新推荐文章于 2023-11-09 08:28:37 发布

云小白66

最新推荐文章于 2023-11-09 08:28:37 发布

阅读量379

点赞数 3

文章标签： leetcode python 算法

本文链接：https://blog.csdn.net/qq_49702508/article/details/118148081

版权

本文涵盖了多种算法问题，包括判断数独的有效性、图像顺时针旋转90度、字符串反转、整数反转、查找字符串中的第一个唯一字符、判断字母异位词、验证回文串、字符串转换为整数以及实现strStr()函数。通过这些算法，深入理解数据结构和逻辑思维在编程中的应用。

摘要由CSDN通过智能技术生成

36.有效的数独（中等）

请你判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。
注意：
一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。

class Solution(object):
    def isValidSudoku(self, board):
        
        # init data
        rows = [{} for i in range(9)]
        columns = [{} for i in range(9)]
        boxes = [{} for i in range(9)]

        # validate a board
        for i in range(9):
            for j in range(9):
                num = board[i][j]
                if num != '.':
                    num = int(num)
                    box_index = (i // 3 ) * 3 + j // 3
                    
                    # keep the current cell value
                    rows[i][num] = rows[i].get(num, 0) + 1
                    columns[j][num] = columns[j].get(num, 0) + 1
                    boxes[box_index][num] = boxes[box_index].get(num, 0) + 1
                    
                    # check if this value has been already seen before
                    if rows[i][num] > 1 or columns[j][num] > 1 or boxes[box_index][num] > 1:
                        return False         
        return True

48. 旋转图像（中等）

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度

你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

class Solution(object):
    def rotate(self, matrix):
        n = len(matrix)
        # 水平翻转
        for i in range(n // 2):
            for j in range(n):
                matrix[i][j], matrix[n - i - 1][j] = matrix[n - i - 1][j], matrix[i][j]
        # 主对角线翻转
        for i in range(n):
            for j in range(i):
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

344. 反转字符串(简单)

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

class Solution(object):
    def reverseString(self, s):
        for i in range(len(s)//2):
            s[i],s[-i-1] = s[-i-1],s[i]

7. 整数反转（简单）

给一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果

如果反转后整数超过 32 位的有符号整数的范围 [-2³¹, 2³¹ − 1] ，就返回 0。假设环境不允许存储 64 位整数（有符号或无符号）。

class Solution(object):
    def reverse(self, x):
        res = 0
        sign = 1
        if x<0:
            sign = -1
            x = x*sign
        while x != 0:
        # 每次取末尾数字
            tmp = x % 10
            # 判断是否 大于 最大32位整数
            if res > 214748364 or (res == 214748364 and tmp > 7):
                return 0
            # 判断是否 小于 最小32位整数
            if res < -214748364 or (res == -214748364 and tmp < -8):
                return 0
            res = res * 10 + tmp
            x = int(x / 10)
        return sign*res

387. 字符串中的第一个唯一字符（简单）

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1

方法一：使用哈希表存储频数

在第一次遍历时，我们使用哈希映射统计出字符串中每个字符出现的次数。在第二次遍历时，我们只要遍历到了一个只出现一次的字符，那么就返回它的索引，否则在遍历结束后返回 -1−1。

class Solution(object):
    def firstUniqChar(self, s):
        frequency = collections.Counter(s)
        for i, ch in enumerate(s):
            if frequency[ch] == 1:
                return i
        return -1

方法二：使用哈希表存储索引

对方法一进行修改，使得第二次遍历的对象从字符串变为哈希映射。具体地，对于哈希映射中的每一个键值对，键表示一个字符，值表示它的首次出现的索引（如果该字符只出现一次）或者 -1（如果该字符出现多次）。当第一次遍历字符串时，设当前遍历到的字符为 c，如果 c不在哈希映射中，我们就将 c与它的索引作为一个键值对加入哈希映射中，否则我们将 c在哈希映射中对应的值修改为 -1。在第一次遍历结束后，我们只需要再遍历一次哈希映射中的所有值，找出其中不为 -1 的最小值，即为第一个不重复字符的索引。如果哈希映射中的所有值均为 -1，我们就返回 -1。

class Solution:
    def firstUniqChar(self, s) :
        position = dict()
        n = len(s)
        for i, ch in enumerate(s):
            if ch in position:
                position[ch] = -1
            else:
                position[ch] = i
        first = n
        for pos in position.values():
            if pos != -1 and pos < first:
                first = pos
        if first == n:
            first = -1
        return first

242. 有效的字母异位词（简单）

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词

示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:
输入: s = “rat”, t = “car”
输出: false

解题思路一：

这道题没有解释什么是异位词，简单说就是两字符串长度相同，字母相同，顺序不同。知道了这，这个题目就很简单了，借助一个哈希表就可以了

from collections import Counter
class Solution:
    def isAnagram(self, s, t) :
        if len(s) != len(t):
            return False
        s_count = Counter(s)
        t_count = Counter(t)
        for key, value in s_count.items():
            t_value = t_count.get(key, 0)
            if value != t_value:
                return False
        return True

125. 验证回文串（简单）

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写

说明：本题中，我们将空字符串定义为有效的回文串

解题思路：筛选 + 判断

最简单的方法是对字符串 s 进行一次遍历，并将其中的字母和数字字符进行保留，放在另一个字符串 sgood 中。这样我们只需要判断 sgood 是否是一个普通的回文串即可，判断的方法有两种。

第一种是使用语言中的字符串翻转 API sgood 的逆序字符串 sgood_rev，只要这两个字符串相同，那么sgood 就是回文串

class Solution:
    def isPalindrome(self, s) :
        sgood = "".join(ch.lower() for ch in s if ch.isalnum())
        return sgood == sgood[::-1]

第二种是使用双指针。初始时，左右指针分别指向sgood 的两侧，随后不断地将这两个指针相向移动，每次移动一步，并判断这两个指针指向的字符是否相同。当这两个指针相遇时，就说明sgood 时回文串

class Solution:
    def isPalindrome(self, s) :
        sgood = "".join(ch.lower() for ch in s if ch.isalnum())
        n = len(sgood)
        left, right = 0, n - 1
        while left < right:
            if sgood[left] != sgood[right]:
                return False
            left, right = left + 1, right - 1
        return True

8. 字符串转换整数 (atoi)（中等）

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）

函数 myAtoi(string s) 的算法如下：

（1）读入字符串并丢弃无用的前导空格
（2）检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。确定最终结果是负数还是正数。如果两者都不存在，则假定结果为正。
（3）读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
（4）如果整数数超过 32 位有符号整数范围 [−2³¹, 2³¹ − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −2³¹ 的整数应该被固定为 −2³¹ ，大于 2³¹ − 1 的整数应该被固定为 2³¹ − 1 。返回整数作为最终结果。
注意：
本题中的空白字符只包括空格字符 ’ ’ 。
除前导空格或数字后的其余字符串外，请勿忽略任何其他字符。

28. 实现 strStr()（简单）

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        a=len(needle)
        b=len(haystack)
        if a==0:
            return 0
        next=self.getnext(a,needle)
        p=-1
        for j in range(b):
            while p>=0 and needle[p+1]!=haystack[j]:
                p=next[p]
            if needle[p+1]==haystack[j]:
                p+=1
            if p==a-1:
                return j-a+1
        return -1

    def getnext(self,a,needle):
        next=['' for i in range(a)]
        k=-1
        next[0]=k
        for i in range(1,len(needle)):
            while (k>-1 and needle[k+1]!=needle[i]):
                k=next[k]
            if needle[k+1]==needle[i]:
                k+=1
            next[i]=k
        return next