【C++代码】反转字符串,反转字符串II,替换空格,翻转字符串里的单词--代码随想录

题目:反转字符串

  • 编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。不要给另外的数组分配额外的空间,你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
题解
  • 对于长度为 N 的待被反转的字符数组,我们可以观察反转前后下标的变化,假设反转前字符数组为 s[0] s[1] s[2] … s[N - 1],那么反转后字符数组为 s[N - 1] s[N - 2] … s[0]。比较反转前后下标变化很容易得出 s[i] 的字符与 s[N - 1 - i] 的字符发生了交换的规律,因此我们可以得出如下双指针的解法:

    • 将 left 指向字符数组首元素,right 指向字符数组尾元素。

    • 当 left < right

      • 交换 s[left] 和 s[right]
      • left 指针右移一位,即 left = left + 1
      • right 指针左移一位,即 right = right - 1
    • 当 left >= right,反转结束,返回字符数组即可。

  • class Solution {
          
          
    public:
        void reverseString(vector<char>& s) {
          
          
            char temp_char;
            int len_s = s.size();
            // for(int i=0;i<len_s/2;i++){
          
          
            //     temp_char = s[i];
            //     s[i]=s[len_s-i-1];
            //     s[i]=temp_char;
            // }
            // for(int i=0;i<s.size();i++){
          
          
            //     cout<<s[len_s-1-i];
            // }
            for(int left=0,right=len_s-1;left<right;left++,right--)
                swap(s[left],s[right]);
        }
    };
    
  • 时间复杂度:O(N),其中 N 为字符数组的长度。一共执行了 N/2 次的交换。空间复杂度:O(1)。只使用了常数空间来存放若干变量。

  • 对于这道题目直接用C++里的一个库函数 reverse,调一下直接完事了, 相信每一门编程语言都有这样的库函数。

  • swap可以有两种实现。一种就是常见的交换数值,一种就是通过位运算:

    • int tmp = s[i];
      s[i] = s[j];
      s[j] = tmp;
      //位运算
      s[i] ^= s[j];
      s[j] ^= s[i];
      s[i] ^= s[j];
      

题目:反转字符串 II

  • 给定一个字符串 s 和一个整数 k,从字符串开头算起,每计数至 2k 个字符,就反转这 2k 字符中的前 k 个字符。如果剩余字符少于 k 个,则将剩余字符全部反转。如果剩余字符小于 2k 但大于或等于 k 个,则反转前 k 个字符,其余字符保持原样。
题解
  • 我们直接按题意进行模拟:反转每个下标从 2k 的倍数开始的,长度为 k 的子串。若该子串长度不足 k,则反转整个子串。

  • class Solution {
          
          
    public:
        string reverseStr(string s, int k) {
          
          
            int len_s = s.size();
            for(int i=0;i<len_s;i+=2*k){
          
          
                if(i+k<=len_s){
          
          
                    reverse(s.begin()+i,s.begin()+i+k);
                }else{
          
          
                    reverse(s.begin()+i,s.end());
                }
            }
            return s;
        }
    };
    
  • 时间复杂度:O(n),其中 n 是字符串 s 的长度。空间复杂度:O(1) 或 O(n),取决于使用的语言中字符串类型的性质。如果字符串是可修改的,那么我们可以直接在原字符串上修改,空间复杂度为 O(1),否则需要使用 O(n) 的空间将字符串临时转换为可以修改的数据结构(例如数组),空间复杂度为 O(n)。

题目:替换空格

  • 请实现一个函数,把字符串 s 中的每个空格替换成"%20"。
题解
  • 如果想把这道题目做到极致,就不要只用额外的辅助空间了!首先扩充数组到每个空格替换成"%20"之后的大小。然后从后向前替换空格,也就是双指针法,过程如下:i指向新长度的末尾,j指向旧长度的末尾。

  • 在 C++ 语言中, string 被设计成「可变」的类型,因此可以在不新建字符串的情况下实现原地修改。由于需要将空格替换为 “%20” ,字符串的总字符数增加,因此需要扩展原字符串 s 的长度,计算公式为:新字符串长度 = 原字符串长度 + 2 * 空格个数

    • 初始化:空格数量 count ,字符串 s 的长度 len ;

    • 统计空格数量:遍历 s ,遇空格则 count++ ;

    • 修改 s 长度:添加完 “%20” 后的字符串长度应为 len + 2 * count ;

    • 倒序遍历修改:i 指向原字符串尾部元素, j 指向新字符串尾部元素;当 i = j 时跳出(代表左方已没有空格,无需继续遍历);

      • 当 s[i] 不为空格时:执行 s[j] = s[i] ;

      • 当 s[i] 为空格时:将字符串闭区间 [j-2, j] 的元素修改为 “%20” ;由于修改了 3 个元素,因此需要 j -= 2 ;

    • 返回值:已修改的字符串 s ;

  • class Solution {
          
          
    public:
        string replaceSpace(string s) {
          
          
            int count_space = 0;
            int len_s=s.size();
            for(int i=0;i<s.size();i++){
          
          
                if(s[i]==' ')count_space++;
            }
            s.resize(len_s+2*count_space);
            for(int i=len_s-1,j=s.size()-1;i<j;i--,j--){
          
          
                if(s[i]==' '){
          
          
                    s[j]='0';
                    s[j-1]='2';
                    s[j-2]='%';
                    j-=2;
                }else{
          
          
                    s[j]=s[i];
                }
            }
            return s;
        }
    };
    
  • 时间复杂度 O(N): 遍历统计、遍历修改皆使用 O(N) 时间。空间复杂度 O(1): 由于是原地扩展 s 长度,因此使用 O(1) 额外空间。

题目:反转字符串中的单词

  • 给你一个字符串 s ,请你反转字符串中 单词 的顺序。单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。注意:输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中,单词间应当仅用单个空格分隔,且不包含任何额外的空格。

  • 输入: "  hello world!  " ;输出: “world! hello” ;

    • 解释: 输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
题解
  • 我们也可以不使用语言中的 API,而是自己编写对应的函数。在不同语言中,这些函数实现是不一样的,主要的差别是有些语言的字符串不可变(如 Java 和 Python),有些语言的字符串可变(如 C++)。

  • 想一下,我们将整个字符串都反转过来,那么单词的顺序指定是倒序了,只不过单词本身也倒序了,那么再把单词反转一下,单词不就正过来了。所以解题思路如下:

    • 移除多余空格:逻辑很简单,从前向后遍历,遇到空格了就erase。如果不仔细琢磨一下erase的时间复杂度,还以为以上的代码是O(n)的时间复杂度呢。想一下真正的时间复杂度是多少,一个erase本来就是O(n)的操作。erase操作上面还套了一个for循环,那么代码移除冗余空格的代码时间复杂度为 O ( n 2 ) O(n^2) O(n2)。那么使用双指针法来去移除空格,最后resize(重新设置)一下字符串的大小,就可以做到O(n)的时间复杂度

    • 将整个字符串反转

    • 将每个单词反转

  • // class Solution {
          
          
    // public:
    //     void reverseStr(string& s,int start,int end){
          
          
    //         for(int i=start,j=end;i<j;i++,j--){
          
          
    //             swap(s[i],s[j]);
    //         }
    //     }
    //     void removeSomeSpace(string& s){
          
          
    //         int slow=0;
    //         for(int i=0;i<s.size();i++){
          
          
    //             if(s[i]==' '){
          
          
    //                 if(slow!=0)//手动控制空格,给单词之间添加空格。
    //                 //slow != 0说明不是第一个单词,需要在单词前添加空格。
    //                     s[slow++]=' ';
    //                 while(i<s.size()&&s[i]!=' '){
          
          
    //                     s[slow++]=s[i++];
    //                 }
    //             }
    //         }
    //         s.resize(slow);
    //     }
    //     string reverseWords(string s) {
          
          
    //         removeSomeSpace(s);
    //         reverseStr(s,0,s.size()-1);
    //         int start=0;
    //         for(int i=0;i<=s.size();i++){
          
          
    //             if(i==s.size()||s[i]==' '){
          
          
    //                 reverseStr(s,start,i-1);
    //                 start=i+1;
    //             }
    //         }
    //         return s;
    //     }
    // };
    class Solution {
          
          
    public:
        void reverse(string& s, int start, int end){
          
           //翻转,区间写法:左闭右闭 []
            for (int i = start, j = end; i < j; i++, j--) {
          
          
                swap(s[i], s[j]);
            }
        }
        void removeExtraSpaces(string& s) {
          
          //去除所有空格并在相邻单词之间添加空格, 快慢指针。
            int slow = 0;   //整体思想参考https://programmercarl.com/0027.移除元素.html
            for (int i = 0; i < s.size(); ++i) {
          
           //
                if (s[i] != ' ') {
          
           //遇到非空格就处理,即删除所有空格。
                    if (slow != 0) s[slow++] = ' '; //手动控制空格,给单词之间添加空格。slow != 0说明不是第一个单词,需要在单词前添加空格。
                    while (i < s.size() && s[i] != ' ') {
          
           //补上该单词,遇到空格说明单词结束。
                        s[slow++] = s[i++];
                    }
                }
            }
            s.resize(slow); //slow的大小即为去除多余空格后的大小。
        }
        string reverseWords(string s) {
          
          
            removeExtraSpaces(s); //去除多余空格,保证单词之间之只有一个空格,且字符串首尾没空格。
            reverse(s, 0, s.size() - 1);
            int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
            for (int i = 0; i <= s.size(); ++i) {
          
          
                if (i == s.size() || s[i] == ' ') {
          
           //到达空格或者串尾,说明一个单词结束。进行翻转。
                    reverse(s, start, i - 1); //翻转,注意是左闭右闭 []的翻转。
                    start = i + 1; //更新下一个单词的开始下标start
                }
            }
            return s;
        }
    };
    

猜你喜欢

转载自blog.csdn.net/weixin_43424450/article/details/132592202