算法通关村——字符串问题解析

２.白银挑战——字符串经典基础面试题

1.反转的问题

1.1反转字符串

LeetCode344：编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组s的形式给出。使用O(1)的额外空间解决这一问题

方法：双指针方法

比较反转前后下标变化很容易得出s[i]的字符与s[N-1-i]的字符发生了交换的规律

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

class solution:
    def reverseString(self, s):
        if s is None or len(s) == 0:
            return s
        left, right = 0, len(s) - 1
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
        return s

if __name__ == "__main__":
    s = list("hello")
    reverseString = solution()
    reverseString.reverseString(s)
    print(''.join(s))

1.2 K个一组反转

LeetCode541：给定一个字符串s和一个整数k，从字符串开头算起，每计数至2k个字符，就反转这2k字符中的前k个字符。

如果剩余字符少于k个，则将剩余字符全部反转

如果剩余字符小于2k但大于或等于K个，则反转前k个字符，其余字符保持原样。

def reverseStr(s, k):
    if s is None and len(s) == 0:
        return s
    arr = list(s)
    for i in range(0, len(arr), 2 * k):
        arr[i:i+k] = reversed(arr[i:i+k])
    return "".join(arr)

if __name__ == "__main__":
    s = "Hello World"
    k = 3
    print("Original String:", s)
    reversed_str = reverseStr(s, k)
    print("Reversed String:", reversed_str)

1.3仅仅反转字母

LeetCode917：给定一个字符串，返回：“反转后的”字符串，其中不是字母的字符都保留在原地，而所有的字母的位置发生反转。

方法一：使用栈

将s中所有字母单独存入栈中，所以出栈等价于对字母反序操作。（或者，可以用数组存储字母并反序数组）然后，遍历S所有字符，如果是字母我们就选择栈顶元素输出。

方法2：拓展 双转指针

def reverseOnlyLetters(S):
    letters = []
    for c in S:
        if c.isalpha():
            letters.append(c)

    ans = ""
    for c in S:
        if c.isalpha():
            ans += letters.pop()
        else:
            ans += c
    return ans

def reverseOnlyLetter(S):
    if not S:
        return S
    ans = []
    j = len(S) - 1
    for i in range(len(S)):
        if S[j].isalpha():
            while not S[j].isalpha():
                j -= 1
            ans.append(S[j])
            j -= 1
        else:
            ans.append(S[i])
    return "".join(ans)

if __name__ == "__main__":
    S = "Hello-World"
    print("Original String", S)
    reverse_str = reverseOnlyLetter(S)
    print("Reverse String", reverse_str)

1.4 反转字符串里的单词

LeetCode151：给你一个字符串s,，个反转字符串中的所有单词。

单词是由非空格字符组成的字符串，s中使用至少一个空格将字符串中的单词分隔开。请你返回一个反转s中单词顺序并用单个空格相连的字符串。

方法一：使用语言提供的方法实现

def reverseWords(self, s)
	return "".join(reversed(s.split()))

方法二：自己实现上述功能

2.验证回文串

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

Python isalnum() 方法检测字符串是否由字母和数字组成。

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 += 1
            right -= 1
        return True

if __name__ == "__main__":
    s = "A man, a plan, a canal: Panama"
    s1 = "race a car"
    isPalindrome = Solution()
    print(isPalindrome.isPalindrome(s1))

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

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

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

import collections

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

if __name__ == "__main__":
    s = "loveleetcode"
    firstUniqChar = Solution()
    print(firstUniqChar.firstUniqChar(s))

4.判定是否为字符重排

LeetCode242：给定两个字符串s1和s2，请编写一个程序，确定一个字符重新排列后，能否变成另一个字符串。

第一种方法：将两个字符串全部从小到大或者从大到小排列，然后再逐个位置比较，这样不管两个原始字符串是什么，都可以判断出来。

第二种方法：使用Hash

class Solution:
    def isAnagram(self, s, t):
        if len(s) != len(t):
            return False
        sorted_s = "".join(sorted(s))
        sorted_t = "".join(sorted(t))
        return sorted_s == sorted_t

if __name__ == "__main__":
    s = "abcadfhg"
    t = "bcafdagh"
    s1 = "abc"
    t1 = "bad"
    isAnagram = Solution()
    print(isAnagram.isAnagram(s1, t1))