【Leetcode】代码随想录Day8｜字符串1.0

344 反转字符串

初始思路：
可以将字符串看作前后两半，只要两两swap即可。运用双指针法。

class Solution(object):
    def reverseString(self, s):
        left = 0
        right = len(s) - 1

        while left < right:
            tmp = s[left]
            s[left] = s[right]
            s[right] = tmp
            left += 1
            right -= 1

        return s

代码随想录：
一些python相关函数及技巧

1. reverse()和reversed()的in-place

s[:] = reversed(s)
s.reverse()

2. slice和range

s[:] = s[::-1]
s[:] = [s[i] for i in range(len(s) - 1, -1, -1)]

Complexity
time: O(n)
space: O(1)

541 反转字符串II

初始思路：
将【344 反转字符串】作为helper，使用一个while loop，去判断(i+1)k是否超过len(s)，用helper将每隔一个s[ik : (i+1)k]进行反转，如果超过了总长度，就是将剩下的全部，即[i*k:]反转。

问题：
与【344 反转字符串】使用List[String]作为参数的类型，本题s为string，一旦定义，不能对其中的元素进行修改，所以无法用swap。

解决：参考代码随想录，直接list(s)

class Solution(object):
    def reverseStr(self, s, k):
        i = 0
        res = list(s)
        while (i+1)*k < len(res):
            res[i*k:(i+1)*k] = self.reverse_string(res[i*k:(i+1)*k])
            i += 2
        if i*k < len(res):
            res[i*k:] = self.reverse_string(res[i*k:])

        return "".join(res)

    def reverse_string(self, s):
        left = 0
        right = len(s) - 1
        while left < right:
            tmp = s[left]
            s[left] = s[right]
            s[right] = tmp
            left += 1
            right -= 1
        return s

代码随想录

• 将while loop改为for loop，其实只在找每个2k的开头，即step=2*k
• 注意python的特性：对于字符串s = ‘abc’，如果使用s[0:999] ===> ‘abc’。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。

 Solution:
    def reverseStr(self, s: str, k: int) -> str:
        """
        1. 使用range(start, end, step)来确定需要调换的初始位置
        2. 对于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。
        3. 用切片整体替换，而不是一个个替换.
        """
        def reverse_substring(text):
            left, right = 0, len(text) - 1
            while left < right:
                text[left], text[right] = text[right], text[left]
                left += 1
                right -= 1
            return text
        
        res = list(s)

        for cur in range(0, len(s), 2 * k):
            res[cur: cur + k] = reverse_substring(res[cur: cur + k])
        
        return ''.join(res)

Complexity
time: O(n)
space: O(1) 或O(n) 取决于语言中字符串是否可以修改【python不可以】

替换数字

54 替换数字【卡码网】
初始思路：
遍历s，判断如果是数字将其变成"number"

s = input()
res = ""
for ss in s:
    if ord("0") <= ord(ss) <= ord("9"):
        res += "number"
    else:
        res += ss
print(res)

Complexity
time: O(n)
space: O(1) 或O(n) 取决于语言中字符串是否可以修改【python不可以】

代码随想录

• 其实很多数组填充类的问题，其做法都是先预先给数组扩容带填充后的大小，然后在从后向前进行操作。
• 从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素整体向后移动。
• 下面有c++的代码，但是python的字符串是不可能改的，无法适用。

#include<iostream>
using namespace std;
int main() {
    string s;
    while (cin >> s) {
        int count = 0; // 统计数字的个数
        int sOldSize = s.size();
        for (int i = 0; i < s.size(); i++) {
            if (s[i] >= '0' && s[i] <= '9') {
                count++;
            }
        }
        // 扩充字符串s的大小，也就是每个空格替换成"number"之后的大小
        s.resize(s.size() + count * 5);
        int sNewSize = s.size();
        // 从后先前将空格替换为"number"
        for (int i = sNewSize - 1, j = sOldSize - 1; j < i; i--, j--) {
            if (s[j] > '9' || s[j] < '0') {
                s[i] = s[j];
            } else {
                s[i] = 'r';
                s[i - 1] = 'e';
                s[i - 2] = 'b';
                s[i - 3] = 'm';
                s[i - 4] = 'u';
                s[i - 5] = 'n';
                i -= 5;
            }
        }
        cout << s << endl;
    }
}

Complexity
time: O(n)
space: O(1)

151 反转字符串里的单词

初始思路：
遍历字符串，跳过空格，将每个单词提取出来，存在数组中。反转数组，遍历数组，为每个单词间隙加一个空格。

class Solution(object):
    def reverseWords(self, s):
        # 相当于自己写了split函数
        word_list = []
        w = ""
        for i in range(len(s)):
            if s[i] == " ":
                if i > 0 and s[i-1] != " ":
                    word_list.append(w)
                continue
            
            if i == 0 or s[i-1] == " ":
                w = s[i]
            else:
                w += s[i]
            if i == len(s) - 1:
                word_list.append(w)

        word_list.reverse() 

        res = word_list[0]
        for w in word_list[1:]:
            res += " "
            res += w

        return res

代码随想录

1. 去掉多余空格（保留词间空格）
2. 反转整个字符串
3. 再反转每个单词

class Solution:
    def reverseWords(self, s: str) -> str:
        # 将字符串拆分为单词，即转换成列表类型
        words = s.split()

        # 反转单词
        left, right = 0, len(words) - 1
        while left < right:
            words[left], words[right] = words[right], words[left]
            left += 1
            right -= 1

        # 将列表转换成字符串
        return " ".join(words)

Complexity
time: O(n)
space: O(1) 或O(n) 取决于语言中字符串是否可以修改【python不可以】

右旋转字符串

55 右旋转字符串【卡码网】
初始思路：
对于python就用slice即可。

k = int(input())
s = input()
print(s[-k:]+s[:-k])

代码随想录

对于可以修改字符串的语言，如c++，探讨不额外建立空间的方式，思路就是通过 整体倒叙，把两段子串顺序颠倒，两个段子串里的的字符在倒叙一把，负负得正，这样就不影响子串里面字符的顺序了。

#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size(); //获取长度

    reverse(s.begin(), s.end()); // 整体反转
    reverse(s.begin(), s.begin() + n); // 先反转前一段，长度n
    reverse(s.begin() + n, s.end()); // 再反转后一段

    cout << s << endl;

}