【代码随想录】541. 反转字符串 II | 151. 反转字符串中的单词

541. 反转字符串 II

规则：这个规则是给我们一个字符串。让我们把前２k段中前k段进行反转。如果末尾不够两k段，但是超过1k这个长度，则把前k段进行反转。如果没超过1k这个长度，则把尾部段进行反转。

为什么很多同学在写这个代码的时候会写的很复杂？因为同学们在店里这个字符串的时候很习惯的去写ｉ＋＋。

其实我们这道题在每次遍历的时候都是以2k进行增加的，每次都是2k段。所以这里没有必要去写ｉ＋＋是要写i＋＝2k，直接让i以2k去移动，在每次操作的时候操作前k个就可以了。相当于操作i到i＋k段这个字符串的距离。

有些同学习惯性的写ｉ＋＋，而为了在2k的时候做一个控制，再声明一个计数的变量ｃｏｕｎｔ

然后再对前k个进行操作，那么这道题就做复杂了。简洁的写法就是让ｉ每2k个进行遍历。

Python中的reverse（）

在Python中，reverse() 是一个列表（list）对象的方法，用于就地（in-place）反转列表中的元素顺序。这意味着该方法会直接修改原始列表，而不是创建一个新的列表。调用 reverse() 方法后，原始列表的元素顺序会被反转，而列表的引用（即列表在内存中的位置）保持不变。

这里有一个简单的例子来说明 reverse() 方法的使用：

# 创建一个列表  
my_list = [1, 2, 3, 4, 5]  
  
# 调用 reverse() 方法反转列表  
my_list.reverse()  
  
# 打印反转后的列表  
print(my_list)  # 输出: [5, 4, 3, 2, 1]

reverse() 方法只能用于列表（list）类型，不能用于字符串（str）、元组（tuple）或其他不可变序列类型。对于字符串和元组，由于它们是不可变的，你不能直接修改它们，但你可以使用切片操作或列表推导式等方法来创建一个新的反转序列。

my_string = "hello"  
reversed_string = my_string[::-1]  # 使用切片创建反转字符串  
print(reversed_string)  # 输出: olleh


my_tuple = (1, 2, 3, 4, 5)  
reversed_tuple = tuple(reversed(list(my_tuple)))  # 转换为列表，反转，再转换回元组  
print(reversed_tuple)  # 输出: (5, 4, 3, 2, 1)

注意，这里我使用了 reversed() 函数，但它返回的是一个迭代器，而不是一个列表。为了将其转换回元组，我首先使用 list() 函数将其转换为列表，然后再使用 tuple() 函数将其转换回元组。然而，在这个特定的例子中，直接使用切片操作（如果元组是由可哈希的元素组成的，比如整数）来创建一个新的元组可能不是直接可行的，因为元组本身不支持切片操作（尽管你可以通过转换为列表来间接实现）。但在这个上下文中，我们主要关注 reverse() 方法在列表上的应用

len()函数是Python中非常常用的一个内置函数，它不仅适用于字符串，还适用于列表、元组、字典、集合等Python中几乎所有的容器类型，用于获取这些容器中包含的元素数量。

python代码：

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        n = len(s)
        res = list(s)
        def re_str(text_list):
            left = 0
            right = len(text_list)-1
            while left < right:
                text_list[left], text_list[right] = text_list[right], text_list[left]
                left += 1
                right -= 1
            return text_list
        for i in range(0,n,2*k): 
            res[i:i+k] = re_str(res[i:i+k])

        return ''.join(res)

''.join(res)

在Python中，''.join(res) 是一个常用的字符串操作方法，它用于将序列（如列表、元组等）res 中的所有元素合并成一个新的字符串。这里的''是一个空字符串，作为分隔符使用，意味着在合并过程中，res 中的元素之间不会插入任何字符或字符串作为分隔。

res = ['Hello', 'world', '!']  
new_string = ''.join(res)  
print(new_string)  # 输出: Helloworld!

151. 反转字符串中的单词

strip()

strip() 是 Python 字符串（String）对象的一个方法，用于移除字符串头尾指定的字符（默认为空格或换行符\n、制表符\t等空白符）。这个方法不会改变原始字符串，而是返回一个新的字符串。

str.strip([chars])

• str：要处理的字符串。
• chars（可选）：要移除的字符集合。如果省略或为None，则默认移除空白字符（包括空格、换行\n、制表符\t等）。如果指定了chars参数，则只会移除字符串头尾那些出现在chars中的字符。

  s = "   Hello, World!   "  
  print(s.strip())  # 输出: Hello, World!
  
  s = "xxxHello, World!xxx"  
  print(s.strip('x'))  # 输出: Hello, World!
  
  #在这个例子中，strip('x')会移除字符串s两端的'x'字符，直到遇到不是'x'的字符为止。
  
  s = "!!Hello, World!!!"  
  print(s.strip('! '))  # 输出: Hello, World

  注意事项

• strip()只移除字符串两端的字符，不会修改字符串中间的字符。
• 如果chars参数为空字符串''，则strip()返回原字符串的副本，因为没有任何字符可以被移除。
• strip()不会改变原始字符串，而是返回一个新的字符串。

字符串的split方法

在Python中，并没有直接名为split的“库函数”作为一个独立的函数存在于某个库中，但split是字符串（str）类型的一个非常常用的方法。这个方法用于将字符串分割成列表，基于指定的分隔符。

split方法的基本语法如下：

str.split(sep=None, maxsplit=-1)

• sep：可选参数，用于指定分隔符，默认为None，表示任何空白字符（如空格、换行\n、制表符\t等）都可以作为分隔符。如果指定了分隔符，则只有该分隔符会被用来分割字符串。
• maxsplit：可选参数，指定分割操作的最大次数。如果设置了maxsplit，则分割操作会在达到最大次数后停止，即使字符串中还存在分隔符。默认为-1，表示分割操作会一直进行到字符串末尾

• # 使用默认分隔符（空白字符）  
  s = "Hello World"  
  print(s.split())  # 输出: ['Hello', 'World']  
    
  # 使用指定分隔符  
  s = "apple,banana,cherry"  
  print(s.split(','))  # 输出: ['apple', 'banana', 'cherry']  
    
  # 指定最大分割次数  
  s = "one:two:three:four"  
  print(s.split(':', 2))  # 输出: ['one', 'two', 'three:four']
  
  #如果你想要根据特定的分隔符来分割字符串，可以将该分隔符作为参数传递给 split() 方法。例如，如果你想要根据逗号来分割字符串：
  s = "Hello, this is a test string."  
  words = s.split()  
  print(words)
  
  #输出将会是：
  ['Hello,', 'this', 'is', 'a', 'test', 'string.']

  注意

  虽然split不是某个库中的函数，但它是Python标准库中字符串类型的一个内置方法，因此无需额外导入任何库即可使用。在Python中，字符串类型（str）提供了丰富的内置方法，用于执行各种字符串操作，split只是其中之一。

• 一些同学会使用split库函数，分隔单词，然后定义一个新的string字符串，最后再把单词倒序相加，那么这道题题目就是一道水题了，失去了它的意义。

 s = ' '.join(word[::-1] for word in s.split())

这行代码是Python中的一种高级用法，它结合了列表推导式（list comprehension）和字符串的join方法，来实现一个特定的文本处理功能。具体来说，这行代码的作用是：将字符串s按空格分割成单词列表，然后将每个单词反转（即字符顺序颠倒），最后再用空格将这些反转后的单词重新连接起来形成一个新的字符串。

让我们逐步分析这行代码：

1. s.split()：这个方法将字符串s按照空格分割成一个单词列表。默认情况下，split()方法不使用任何参数时，会按照空白字符（如空格、换行\n、制表符\t等）来分割字符串，但在这个上下文中，我们假设s是由空格分隔的单词组成的字符串。

2. word[::-1]：这是Python中的切片（slicing）操作，用于反转字符串或列表。[::-1]表示从字符串或列表的末尾开始，到开头结束，步长为-1，即反向选取所有元素。这里它被用于反转每个单词。

3. word[::-1] for word in s.split()：这是一个列表推导式，它遍历s.split()返回的单词列表，对每个单词应用[::-1]反转操作，生成一个新的反转单词列表。

4. ' '.join(...)：join是字符串的一个方法，它接受一个可迭代对象（如列表）作为参数，并将可迭代对象中的元素（这些元素都应该是字符串）使用指定的分隔符（在这个例子中是空格' '）连接起来，形成一个新的字符串。

综上所述，整行代码' '.join(word[::-1] for word in s.split())的作用是：将字符串s中的每个单词反转，然后将这些反转后的单词用空格连接起来形成一个新的字符串。

s = "hello world"  
new_s = ' '.join(word[::-1] for word in s.split())  
print(new_s)  # 输出: olleh dlrow

python代码（split（）方法）

（版本一）先删除空白，然后整个反转，最后单词反转。 因为字符串是不可变类型，所以反转单词的时候，需要将其转换成列表，然后通过join函数再将其转换成列表，所以空间复杂度不是O(1)

class Solution:
    def reverseWords(self, s: str) -> str:
        # 删除前后空白
        s = s.strip()
        # 反转整个字符串
        s = s[::-1]
        # 将字符串拆分为单词，并反转每个单词
        s = ' '.join(word[::-1] for word in s.split())
        return s

python代码（双指针）：

更新ing