[leetcode] Python(6)--反转字符串(344)、整数反转(7)、字符串中的第一个唯一字符(387)、有效的字母异位词(242)

本文链接：https://blog.csdn.net/qweqwrqw/article/details/89104470

从零开始的力扣（第六天）~

1.反转字符串

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

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：
输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：
输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]
—————————————————————————————————————————

应该是最简单的写法，一行搞定

class Solution(object):
    def reverseString(self, s):
        """
        :type s: List[str]
        :rtype: None Do not return anything, modify s in-place instead.
        """
        s[:] = s[:][::-1]

在这里插入图片描述

通过首末交换的思路，循环搞定

class Solution:
    def reverseString(self, s) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        start, end = 0, len(s) - 1
        while start < end:
            s[start], s[end] = s[end], s[start]
            start += 1
            end -= 1

在这里插入图片描述
此题不考虑使用reverse()函数。

2.整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:
输入: 123
输出: 321

示例 2:
输入: -123
输出: -321

示例 3:
输入: 120
输出: 21

注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2³¹, 2³¹ − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
—————————————————————————————————————————

通过将数字转换成字符串再读入列表进行操作

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        List = list(str(x))
        if List[0] == "-":
            List.pop(0)
            List.reverse()
            a = int(''.join(List))
            if a > 2 ** 31:
                return 0
            else:
                return -a
        else:
            List.reverse()
            a = int(''.join(List))
            if a > 2 ** 31 - 1:
                return 0
            else:
                return a

在这里插入图片描述
注意里面的操作，其中转换成list的语法为：

a = 123
b = str(a)
c = list(st)

在这里插入图片描述

直接对字符串操作，不转换为列表

class Solution:
    def reverse(self, x: int) -> int:
        x = str(x)
        if x[0] == '-':
            x = int('-'+x[::-1][:-1])
        else:
            x = int(x[::-1])
        if -2**31<=x<=2**31-1:
            return x
        else:
            return 0

在这里插入图片描述
注意这里的字符串翻转操作，前一个[::-1]表示从后向前翻转，而后面的[:-1]表示翻转到第一位停止翻转，就达到了我们要的要求：

a = -123
b = str(a)
c = int('-' + b[::-1][:-1])

在这里插入图片描述

3.字符串中的第一个唯一字符

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

案例:
s = “leetcode”
返回 0.

s = “loveleetcode”,
返回 2.

注意事项：您可以假定该字符串只包含小写字母。
—————————————————————————————————————————

通过遍历整个字符串，发现字符数目为1时返回（未通过）

class Solution(object):
    def firstUniqChar(self, s):
        """
        :type s: str
        :rtype: int
        """
        for i in list(s):
            if s.count(i) == 1:
                return s.find(i)
            else:
                continue
        return -1

在这里插入图片描述
主要问题在于，当出现特别长的字符串时，由于遍历所有字符，那么会超出时间限制。

主要为了解决长字符串问题，想到使用set()函数

class Solution(object):
    def firstUniqChar(self, s):
        """
        :type s: str
        :rtype: int
        """
        l = [s.find(i) for i in set(s) if s.find(i) == s.rfind(i)]
        return min(l) if l else -1

在这里插入图片描述
主要使用find()函数，并且在set()函数限制下最多只找寻26个字母，通过s.find()与s.rfind()确定字母唯一，需要知道的是find()是从左向右查找，rfind()是从右向左查找，二者返回查找到的字符的下标。

通过建立字典，将所有字母与个数存储下来，再循环并且向字典内查找

class Solution(object):
    def firstUniqChar(self, s):
        """
        :type s: str
        :rtype: int
        """
        d = {}
        for i in s:
            if i not in d:
                d[i] = 1
            else:
                d[i] += 1
        for i in range(len(s)):
            if s[i] in d and d[s[i]] == 1:
                return i
            else:
                continue
        return -1

在这里插入图片描述
通过字典查找可以大大缩短查找时间，加快查找效率。

4.有效的字母异位词

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

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

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

说明:
你可以假设字符串只包含小写字母。

进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
—————————————————————————————————————————
注意不要再遍历两个字符串了，因为当字符串过长时，时间复杂度很高。

对s与t分别建立两个字典，再进行比较

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        d1 = {}
        d2 = {}
        for i in s:
            if i not in d1:
                d1[i] = 1
            else:
                d1[i] += 1
        for i in t:
            if i not in d2:
                d2[i] = 1
            else:
                d2[i] += 1
        return not cmp(d1,d2)

在这里插入图片描述
其中cmp()比较函数输出为：当两个字典相同时为0，当两个字典不同时为1或-1。

通过排序方法解决

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        return sorted(s) == sorted(t)