算法训练Day8

2023年3月8日

今天的任务有5个

#反转字符串 344. 反转字符串 - 力扣（LeetCode）

直接reverse解决问题

class Solution {
public:
    void reverseString(vector<char>& s) {
        reverse(s.begin(),s.end());
    }
};

这样的话这道题就失去了本身的意义，那么反转字符串用什么方法呢？

可以设置两个指针一前一后，同时往中间移动，交换两个指针所指位置的字符，当两个指针相交的时候运算结束，代码如下

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]);
        }
    }
};

这里再给出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

这道题我一开始不太明白啥意思，我以为一直就是前k个元素换，后来看了解析我发现我错了，是通过不断移动i，然后重新判断2*k个元素的前k个元素

思路比较简单，就是不断移动i值，使i每次移动到下一次要反转的位置，根据剩余的长度进行不同的操作，代码如下

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s.begin() + i, s.begin() + i + k );
            } else {
                // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

如果自己实现reverse是一样的，代码如下

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]);
        }
    }
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s, i, i + k - 1);
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
            reverse(s, i, s.size() - 1);
        }
        return s;
    }
};

另一种思路的解法

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.size(),pos = 0;
        while(pos < n){
            //剩余字符串大于等于k的情况
            if(pos + k < n) reverse(s.begin() + pos, s.begin() + pos + k);
            //剩余字符串不足k的情况 
            else reverse(s.begin() + pos,s.end());
            pos += 2 * k;
        }
        return s;
    }
};

#剑指Offer 05.替换空格

第一次做的时候我简单的理解为直接设置一个方法，把空格改为%20就可以了，没有考虑到数组容量不够的情况

后来发现可以不只用额外的辅助空间了，可以先统计字符串中空格的个数，假如为count，然后扩展2*count个新空间，这种情况下相当于扩容，然后设置两个指针，一个指针指向原来数组的末尾，另一个指针指向扩展后的数组的末尾，同时从后向前动，当前面的指针(假设为i)指向非空字符时，将前面的指针指向的字符“复制”到后面指针所指的位置上，当前面的指针指向空格的时候，后面的指针依次往前赋值"0","2","%"，然后继续移动i指针，以此类推，当i==j的时候，说明算法结束，代码如下：

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的大小，也就是每个空格替换成"%20"之后的大小
        s.resize(s.size() + count * 2);
        int sNewSize = s.size();
        // 从后先前将空格替换为"%20"
        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;
    }
};

代码随想录中给出了字符数组跟字符串的区别，为保证完整性，这里给出原文

这里也给大家拓展一下字符串和数组有什么差别，

字符串是若干字符组成的有限序列，也可以理解为是一个字符数组，但是很多语言对字符串做了特殊的规定，接下来我来说一说C/C++中的字符串。

在C语言中，把一个字符串存入一个数组时，也把结束符 '\0'存入数组，并以此作为该字符串是否结束的标志。

例如这段代码：

char a[5] = "asd";
for (int i = 0; a[i] != '\0'; i++) {
}

在C++中，提供一个string类，string类会提供 size接口，可以用来判断string类字符串是否结束，就不用'\0'来判断是否结束。

例如这段代码:

string a = "asd";
for (int i = 0; i < a.size(); i++) {
}

那么vector< char > 和 string 又有什么区别呢？

其实在基本操作上没有区别，但是 string提供更多的字符串处理的相关接口，例如string 重载了+，而vector却没有。

所以想处理字符串，我们还是会定义一个string类型

#翻转字符串里的单词

一开始想的是，直接把字符串s按空格分割开来，然后会得到一个按顺序的、只有单词没有空格的若干个字符串，然后再倒序输入到新数组中，通过这个方式解决这个问题，虽然也能解决，但是并没有学到任何东西，下面是代码随想录中给出的思路，以前没有接触过，这里就直接借鉴了

解题的思路分为三步：①去除原字符串中所有的空格②将整个字符串进行倒序③将每个单词进行倒序

这里给出使用双指针法去除原字符串中的所有空格

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的大小即为去除多余空格后的大小。
}

说明一下，fast指向的是要移动的元素，slow指向的是需要移动的元素所要移动到的位置，具体的原理跟移除元素那道题基本一模一样，因为翻转以后，每个单词之间也需要留有空格，所以slow在移动的时候，需要多留出来一个空格的位置，即s[slow++] = ' '，为什么要slow != 0呢？因为移动到新数组的首位置的时候，首位置是不需要空格的，所以加了一个限制条件，当我slow指向的位置不是第一个单词的时候，我就将slow所指位置赋值为空格，然后slow++移动到下一个位置，当下一个位置不是空格的时候，我就将i指向的元素赋值到slow所指位置，这样就完成了在原字符串的基础上进行删除空格的操作，最后slow所指的位置就是字符串变完后的长度，进行resize更改长度，就完成了整个的操作，完整代码如下

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;
    }
};

#剑指Offer58-II.左旋转字符串 剑指 Offer 58 - II. 左旋转字符串 - 力扣（LeetCode）

有了上一道题的思路，这道题小葱拌豆腐--清清爽爽，直接分两步翻转，一是[0,n]翻转，二是[n,size()]翻转，然后整体再翻转，就达到了左旋的效果，非常神奇！

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;
    }
};

今天这个去除空格这个题很有收获，非常行云流水的操作，明天见！