代码随想录算法训练营第8天| ● 344.反转字符串 ● 541. 反转字符串II ● 剑指Offer 05.替换空格 ● 151.翻转字符串里的单词 ● 剑指Offer58-II.左旋转字符串

合集 - 代码随想录(16)

1.代码随想录算法训练营第二天| 977.有序数组的平方，209.长度最小的子数列，59.螺旋矩阵Ⅱ2023-09-082.代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素2023-09-073.代码随想录算法训练营第三天| 203.移除链表元素 707.设计链表 206.反转链表2023-09-094.代码随想录算法训练营第四天| 24. 两两交换链表中的节点, 19.删除链表的倒数第N个结点，面试题02.07.链表相交，142.环形链表Ⅱ2023-09-105.代码随想录算法训练营第六天| 242.有效的字母异位词，349.两个数组的交集，202.快乐数，1.两数之和2023-09-116.代码随想录算法训练营第7天| ● 454.四数相加II ● 383. 赎金信 ● 15. 三数之和 ● 18. 四数之和2023-09-13

7.代码随想录算法训练营第8天| ● 344.反转字符串 ● 541. 反转字符串II ● 剑指Offer 05.替换空格 ● 151.翻转字符串里的单词 ● 剑指Offer58-II.左旋转字符串2023-09-14

8.代码随想录算法训练营第9天| ●28. 实现 strStr() ●459.重复的子字符串 ●字符串总结 ●双指针回顾 2023-09-149.代码随想录算法训练营第10天| 232.用栈实现队列 ● 225. 用队列实现栈2023-09-1510.代码随想录算法训练营day13| ● 239. 滑动窗口最大值 ● 347.前 K 个高频元素 ● 总结2023-09-1811.代码随想录算法训练营day11| ● 20. 有效的括号 ● 1047. 删除字符串中的所有相邻重复项 ● 150. 逆波兰表达式求值2023-09-1812.代码随想录算法训练营day14| ● 二叉树理论基础 ● 递归遍历 ● 迭代遍历 ● 统一迭代2023-09-2113.代码随想录算法训练营day15 | ● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2 2023-09-2114.代码随想录算法训练营day16 | ● 104.二叉树的最大深度 559.n叉树的最大深度 ● 111.二叉树的最小深度 ● 222.完全二叉树的节点个数2023-09-2115.代码随想录算法训练营day17 | ● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和 2023-09-2316.代码随想录day21 | ● 530.二叉搜索树的最小绝对差 ● 501.二叉搜索树中的众数 ● 236. 二叉树的最近公共祖先 2023-09-27

收起

344.反转字符串

mydemo--(一次就过)--(成功)

class Solution {
public:
    void reverseString(vector<char>& s) {
        int len = s.size();
        char tmp;
        int i=0;
        int j = len-1;

        while(i<j)
        {
            tmp = s[i];
            s[i] = s[j];
            s[j] = tmp;
            i++;
            j--;
        }
    }
};

卡哥代码

class Solution {
public:
    void reverseString(vector<char>& s) {
        for(int i=0, j=s.size()-1; i<s.size()/2; i++,j--)
            swap(s[i], s[j]);
    }
};

541.反转字符串Ⅱ

mydemo--(自己思路)--(失败)

报错：超出时间限制

判断写的太复杂，而且 i是一个一个的跳，太慢了，会超时。

class Solution {
public:
    string reverseStr(string s, int k) {
        
        int i = 0;
        int j = 1;
        int len = s.size();

        while(1)
        {
            if(j-i+1 == 2*k)
            {
                reverse(s, i, i+k-1);
            
                if(j == len-1)  break;
            
                i = j+1;
                j = i+1;
                continue;
            }
            if(j-i+1 < k && j ==len-1)
            {
                reverse(s,i,j);
                break;
            }
            if(j-i+1 <2*k && j == len-1)
            {
                reverse(s,i,i+k-1);
                break;
            }
            
            i++	//一个一个跳，太慢了
        }
        return s;
    }

    void reverse(string& s, int i, int j)
    {
        while(i < j)
        {
            swap(s[i], s[j]);
            i++;
            j--;
        }
    }

};

卡哥代码

卡哥真言：

当操作字符串或者操作数组的时候，如果需要成段成段的处理，那么 i 就可以成段成段的跳，速度会快很多。

class Solution {
public:
    string reverseStr(string s, int k) {
    
    int len = s.size();

    for(int i=0; i<len; i+=2*k)
    {
      if(i+k <= len)
      {
        reverse(s.begin()+i, s.begin()+i+k);  //库函数实现的reverse是左闭右开的
        continue;
      }
      reverse(s.begin()+i, s.end());
    }
    return s;
    }
};

剑指Offer 05.替换空格

mydemo--(自己思路)--(失败)

我的思路肯定是没问题的，只是写法上有瑕疵

注意

C++中单引号表示字符，双引号表示字符串

卡哥demo

又是一道双指针的题。

当对连续序列（数组、字符串）等进行删除，替换操作时，有前向法和后向法：

1. 前向法：

在原序列上定义一个指针，当碰到要删除或者要替换的单位时，进行操作，同时，会对后面的单位进行处理，所以总的时间复杂度会是O(n^2)

2. 后向法

在原序列上进行扩充，然后定义两个指针进行操作。这样做有两个好处：

• 不用申请新数组。
• 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

class Solution {
public:
    string replaceSpace(string s) {

        int count = 0;
        int sOldSize = s.size();
        for(int i=0; i <s.size(); i++)
        {
            if(s[i] == ' ')
            {
                count++;
            }
        }

        s.resize(s.size() + count*2);   //key
        int sNewSize = s.size();
        for(int i = sNewSize - 1, j = sOldSize - 1; j < i; i--,j--)
        {
            if(s[j] != ' ')
            {
                s[i] = s[j];
            }
            else
            {
                s[i] = '0';
                s[i - 1] = '2';
                s[i - 2] = '%';
                i -= 2;
            }
        }
        return s;
    }
};

151.反转字符串中的单词

卡哥demo

双指针法，原地修改

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;
        for(int fast = 0; fast < s.size(); fast++)
        {
            if(s[fast] != ' ')
            {   
                if(slow !=0)
                {
                    s[slow] = ' ';
                    slow++;
                }

                while(fast < s.size() && s[fast] != ' ')
                {
                    s[slow] = s[fast];
                    slow++;
                    fast++;
                }
            }
        }
        s.resize(slow);
    }

    string reverseWords(string s) 
    {
        removeExtraSpaces(s);
        reverse(s, 0, s.size() - 1);
        int start = 0;
        for(int i = 0; i <= s.size(); i++)
        {
            if(i == s.size() || s[i] == ' ')
            {
                reverse(s, start, i-1);
                start = i+1;
            }
        }
        return s;
    }
};

剑指Offer 58 - Ⅱ. 左旋转字符串

卡哥demo

注意，库函数的 reverse( ) 是左闭右开

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        
        reverse(s.begin(), s.begin()+n);
        reverse(s.begin()+n, s.end());
        reverse(s.begin(), s.end());
        return s;
    }
};