力扣-初级算法-字符串

1.Python字符串处理操作方法

• len(s)：返回字符串 s 的长度。
  

• s.lower()：将字符串 s 转换为小写。
  

• s.upper()：将字符串 s 转换为大写。
  

• s.capitalize()：将字符串 s 的第一个字母大写，其余字母小写。
  

• s.title()：将字符串 s 中每个单词的首字母大写。
  

• s.swapcase()：将字符串 s 中大写字母转为小写，小写字母转为大写。
  

• s.find(sub)：返回子串 sub 在字符串 s 中第一次出现的位置，没有找到返回 -1。
  

• s.rfind(sub)：返回子串 sub 在字符串 s 中最后一次出现的位置，没有找到返回 -1。
  

• s.index(sub)：与 find() 类似，但如果没有找到子串 sub，则抛出 ValueError 异常。
  

• s.replace(old, new)：将字符串 s 中的所有 old 子串替换为 new。
  

• s.split(sep)：将字符串 s 按照分隔符 sep 分割成一个列表。如果不指定 sep，默认按空格分割。
  

• s.rsplit(sep)：从右侧开始分割字符串。
  

• s.splitlines()：按行分割字符串。
  

• sep.join(iterable)：将可迭代对象 iterable 中的元素用字符串 sep 连接成一个新字符串。
  

• s.strip()：去除字符串 s 两端的空白字符。
  

• s.lstrip()：去除字符串 s 左侧的空白字符。
  

• s.rstrip()：去除字符串 s 右侧的空白字符。
  

• s.startswith(prefix)：检查字符串 s 是否以 prefix 开头。
  

• s.endswith(suffix)：检查字符串 s 是否以 suffix 结尾。
  

• s.isalpha()：检查字符串 s 是否只包含字母。
  

• s.isdigit()：检查字符串 s 是否只包含数字。
  

• s.isalnum()：检查字符串 s 是否只包含字母和数字。
  

• s.isspace()：检查字符串 s 是否只包含空白字符。
  

• s.format(*args, **kwargs)：使用 args 和 kwargs 中的值格式化字符串 s。
  

• f"{var}"：使用 f-string 格式化字符串。
  

• s.encode(encoding)：将字符串 s 编码为字节对象。
  

• b.decode(encoding)：将字节对象 b 解码为字符串。
  

2.算法题

2.1 反转字符串

题目

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

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

示例

输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

解法

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

分析

• 时间复杂度：O(N)
• 空间复杂度：O(1)

2.2 整数翻转

题目

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

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

示例

输入：x = -123
输出：-321

解法

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        str_x = str(x)
        if str_x[0] == '-':
            reversed_str = '-'+str_x[:0:-1]
        else:
            reversed_str = str_x[::-1]
        y = int(reversed_str)
        if y < -2**31 or y > 2**31 - 1:
            return 0
        return y

分析

• 时间复杂度：O(N)
• 空间复杂度：O(N)

2.3 字符串中的第一个唯一字符

题目

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

示例

输入: s = “loveleetcode”
输出: 2

解法

class Solution(object):
    def firstUniqChar(self, s):
        """
        :type s: str
        :rtype: int
        """
        l = len(s)
        for x in 'abcdefghijklmnopqrstuvwxyz':
            k1 = s.find(x)
            k2 = s.rfind(x)
            if k1==k2 and k1!=-1:
                l=min(k1,l)
        return l if l !=len(s) else -1

分析

• 时间复杂度：O(N)
• 空间复杂度：O(1)

2.4 有效的字母异位词

题目

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

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例

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

解法

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        d1 = {}
        d2 = {}
        for i in s:
            if i in d1:
                d1[i]+=1
            else:
                d1[i]=1
        for j in t:
            if j in d2:
                d2[j]+=1
            else:
                d2[j]=1
        d1=dict(sorted(d1.items()))#sorted()方法需要一个可迭代对象，但是字典本身不可迭代，需要用items()方法返回一个可迭代的对象，每个元素是(key,value)元组
        d2=dict(sorted(d2.items()))
        return True if d1==d2 else False

分析

• 时间复杂度：O(N)
• 空间复杂度：O(N)

2.5 验证回文串

题目

如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。

字母和数字都属于字母数字字符。

给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。

示例

输入: s = “A man, a plan, a canal: Panama”
输出：true
解释：“amanaplanacanalpanama” 是回文串。

解法

class Solution(object):
    def isPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        l1 = [c.lower() for c in s if c.isalnum()]
        return l1 ==l1[::-1]

• 时间复杂度：O(N)
• 空间复杂度：O(N)

2.6 字符串转换整数 (atoi)

题目

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数。

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

空格：读入字符串并丢弃无用的前导空格（" "）
符号：检查下一个字符（假设还未到字符末尾）为 ‘-’ 还是 ‘+’。如果两者都不存在，则假定结果为正。
转换：通过跳过前置零来读取该整数，直到遇到非数字字符或到达字符串的结尾。如果没有读取数字，则结果为0。
舍入：如果整数数超过 32 位有符号整数范围 [−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被舍入为 −231 ，大于 231 − 1 的整数应该被舍入为 231 − 1 。
返回整数作为最终结果。

示例

输入：s = “1337c0d3”

输出：1337

解释：

第 1 步：“1337c0d3”（当前没有读入字符，因为没有前导空格）
^
第 2 步：“1337c0d3”（当前没有读入字符，因为这里不存在 ‘-’ 或者 ‘+’）
^
第 3 步：“1337c0d3”（读入 “1337”；由于下一个字符不是一个数字，所以读入停止）
^

解法

class Solution(object):
    def myAtoi(self, s):
        """
        :type s: str
        :rtype: int
        """
        s = s.lstrip()
        if not s:return 0
        sign=1
        if s[0]=='-':
            sign=-1
            s=s[1:]
        elif s[0]=='+':
            s=s[1:]   
        res=0
        for e in s:
            if not e.isdigit():break
            else:
                res = res*10+int(e)
        res = res*sign
        min_int = -2**31
        max_int = 2**31-1
        if res<min_int:return min_int
        elif res>max_int:return max_int
        return res

分析

• 时间复杂度：O(N)
• 空间复杂度：O(N)

2.7 实现 strStr()

题目

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例

输入：haystack = “sadbutsad”, needle = “sad”
输出：0
解释：“sad” 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

解法

class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        return haystack.find(needle)

分析

• 时间复杂度：O(N)
• 空间复杂度：O(1)

2.8 外观数列

题目

「外观数列」是一个数位字符串序列，由递归公式定义：

countAndSay(1) = “1”
countAndSay(n) 是 countAndSay(n-1) 的行程长度编码。
行程长度编码（RLE）是一种字符串压缩方法，其工作原理是通过将连续相同字符（重复两次或更多次）替换为字符重复次数（运行长度）和字符的串联。例如，要压缩字符串 “3322251” ，我们将 “33” 用 “23” 替换，将 “222” 用 “32” 替换，将 “5” 用 “15” 替换并将 “1” 用 “11” 替换。因此压缩后字符串变为 “23321511”。

给定一个整数 n ，返回 外观数列 的第 n 个元素。

示例

输入：n = 4

输出：“1211”

解释：

countAndSay(1) = “1”

countAndSay(2) = “1” 的行程长度编码 = “11”

countAndSay(3) = “11” 的行程长度编码 = “21”

countAndSay(4) = “21” 的行程长度编码 = “1211”

解法1

class Solution:
    def countAndSay(self, n):
        """
        :type n: int
        :rtype: str
        """
        if n == 1:
            return "1"
        current = "1"
        for _ in range(2, n + 1):
            next_seq = ''
            c = 1
            for i in range(1, len(current)):
                if current[i] == current[i - 1]:
                    c += 1
                else:
                    next_seq += str(c) + current[i - 1]
                    c = 1
            next_seq += str(c) + current[-1]
            current = next_seq
        return current

分析

• 时间复杂度：$$O(2^n)$$
• 空间复杂度：$$O(2^n)$$

解法2

class Solution:
    def countAndSay(self, n: int) -> str:
        if n == 1:
            return '1'
        current = '1'
        for _ in range(2, n + 1):
            result = []
            start, end = 0, 0
            while end < len(current):
                while end < len(current) and current[start] == current[end]:
                    end += 1
                result.append(str(end - start))
                result.append(current[start])
                start = end
            current = ''.join(result)
        return current

分析

• 时间复杂度：$$O(2^n)$$
• 空间复杂度：$$O(2^n)$$

2.9 最长公共前缀

题目

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例

输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”

解法1

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        if not strs:
            return ""
        prefix = strs[0]
        for s in strs[1:]:
            while not s.startswith(prefix):
                prefix = prefix[:-1]
                if not prefix:
                    return ""
        return prefix

分析

• 时间复杂度：O(N+M)
• 空间复杂度：O(1)

解法2

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        if not strs:
            return ""
        strs.sort()
        n=len(strs)
        a=strs[0]     
        b=strs[n-1]
        res=""
        for i in range(len(a)):
            if i<len(b) and a[i]==b[i]:
                res+=a[i]
            else:
                break
        return res        

分析

• 时间复杂度：O(N*LOGN+M)
• 空间复杂度：O(N)