151. 反转字符串中的单词 【中等】

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"
示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。
示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。
 

提示：

1 <= s.length <= 104
s 包含英文大小写字母、数字和空格 ' '
s 中 至少存在一个 单词
 

进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的 原地 解法。

方法一： 自己构造函数不要使用辅助空间，空间复杂度要求为O(1)

class Solution:
    def removeSpaces(self,s):
        left,right=0,len(s)-1
        #去除开头的空格
        while  left<right and s[left]==" ":
            left+=1
        #去除末尾的空格
        while left<right and s[right]==" ":
            right-=1
        #new_s存储去掉多余空格剩下的东西
        new_s=[]
        #去除单词间的多余空格,用Left
        while left<=right:
            if s[left]!=" ":
                new_s.append(s[left])

            elif s[left]==" "and new_s[-1]!=" ":
                new_s.append(s[left])
            #结束判断后指针右移
            left+=1
        return new_s
    #反转字符串
    def reverseString(self, s):
        # 初始化双指针
        left= 0
        right=len(s) - 1
        #当左指针小于右指针的时候
        while left<right:
            s[left],s[right]=s[right],s[left]
            left+=1
            right-=1
        return s
    #反转每个单词
    def reverseEachwords(self,s):
        #初始化指向每个单词前后的指针
        left,right=0,0
        n=len(s)

        while left<n:
            while right<n and s[right]!=' ':#当左边小于n并且循环里面右边小于n，右边递增
                right+=1
            #当不满足条件的时候，反转
            s[left:right]=self.reverseString(s[left:right])
            #反转完一个单词反转下一个
            left=right+1
            right+=1
        return s

    
    def reverseWords(self, s: str) -> str:
        #第一步：去除空格
        s=self.removeSpaces(s)
        #第二步：反转字符串
        s=self.reverseString(s)
        #第三步：反转每个单词
        s=self.reverseEachwords(s)
        #第四步：输出翻转后的字符串
        return "".join(s)

方法二：调用python函数

class Solution:
    def reverseWords(self, s: str) -> str:
        #方法一：调用api
        return " ".join(reversed(s.split()))

 方法三：python切片，也是o1

class Solution:
    def reverseWords(self,s:str)->str:
        #利用python的切片 以空格为分隔符
        s_list=[i for i in s.split(" ") if len(i)>0]
        #返回空格倒序的join
        return " ".join(s_list[::-1])
        #删除头尾空格的方法函数
        def trim_head_tail_space(ss:str):
            #删除首尾的空白符
            p=0#定义指针
            while p<len(ss) and ss[p]==" ":
                p+=1 #当p小于字符长度并且ssp是空格的时候后移，之后返回p之后的
            return ss[p:]
        #移除头尾的空格
        s=trim_head_tail_space(s)
        s=trim_head_tail_space(s[::-1])[::-1]
        #去除尾部的空格,然后倒序排列回来
        #翻转字符串 没有看太懂他这个写的过程
        pf,ps,s=0,0,s[::-1]
        while pf<len(s):
            if s[pf]==" ":#不会去除，因为我们清了头部的空格
                if s[pf]==s[pf+1]:
                    s=s[:pf]+s[pf+1:]
                    continue #此时s为pf前面的和pf+1后面的
                else:
                    s=s[:ps]+s[ps:pf][::-1]+s[pf:]
                    ps,pf=pf+1,pf+2  
            else:
                pf+=1
        return s[:ps]+s[ps:][::-1]        

# 解法二：
class Solution:
    def reverseWords(self, s: str) -> str:
        # method 1 - Rude but work & efficient method.
        s_list = [i for i in s.split(" ") if len(i) > 0]
        return " ".join(s_list[::-1])

        # method 2 - Carlo's idea
        def trim_head_tail_space(ss: str):
            p = 0
            while p < len(ss) and ss[p] == " ":
                p += 1
            return ss[p:]

        # Trim the head and tail space
        s = trim_head_tail_space(s)
        s = trim_head_tail_space(s[::-1])[::-1]

        pf, ps, s = 0, 0, s[::-1] # Reverse the string.
        while pf < len(s):
            if s[pf] == " ":
                # Will not excede. Because we have clean the tail space.
                if s[pf] == s[pf + 1]:
                    s = s[:pf] + s[pf + 1:]
                    continue
                else:
                    s = s[:ps] + s[ps: pf][::-1] + s[pf:]
                    ps, pf = pf + 1, pf + 2
            else:
                pf += 1
        return s[:ps] + s[ps:][::-1] # Must do the last step, because the last word is omit though the pointers are on the correct positions,