算法训练营Day8 第四章 字符串part1

 第一题： 344.反转字符串 

        比较简单的一道题，双指针法就可以解决问题，分别交换两个指针指向的内容即可，通过这道题可以较好地理解双指针法。

class Solution {
public:
    void m_swap(char& a, char& b) {
        int tmp = a;
        a = b;
        b = tmp;
    }
    void reverseString(vector<char>& s) {
        int left = 0;
        int right = s.size() - 1;
        while(left < right) {
            m_swap(s[left], s[right]);
            left++;
            right--;
        }
    }
};

 第二题： 541. 反转字符串Ⅱ

        用模拟法就能解决这道题，根据题目中的要求很容易写出代码，本道题目的关键其实在于精简代码逻辑，可以写出如下代码，每次令i移动2k个位置进行判断就OK。

        

class Solution {
public:
    string reverseStr(string s, int k) {
        for(int i = 0; i < s.size(); i += 2 * k)
        {
            //如果有k个字符串，反转前k个字符串
            if(i + k <= s.size())
            {
                reverse(s.begin()+i,s.begin()+i+k);
                continue;
            }
            //如果剩余不足k个字符串，则全部反转
            reverse(s.begin()+i,s.begin()+s.size());
        }
        return s;
    }
};

             

 第三题： 剑指Offer 05.替换空格 

        这道题一开始我使用了string中的库函数insert，但是后来我发现使用insert的算法时间复杂度应该是O()，后来看了题解发现双指针法是最好的处理方式，双指针法思路为：

        ①首先将数组扩充大小为每个空格替换成"%20"之后的大小。

        ②然后从后向前替换空格。

为什么是从后向前替换空格呢？因为从前向后填充就是O()的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。

                                                             

给出这种方法的代码：

class Solution {
public:
    string replaceSpace(string s) {
        int size = s.size();
        int newsize = size;
        for(int i = 0; i < s.size(); ++i) {
            if(s[i] == ' ') {
                newsize += 2;
            }
        }
        s.resize(newsize);
        for(int l = size - 1, r = newsize - 1; l >= 0; l--, r--) {
            if(s[l] != ' ') {
                s[r] = s[l];
            }
            else {
                s[r--] = '0';
                s[r--] = '2';
                s[r] = '%';
            }
        }
        return s;
    }
};

                                   

第四题： 151.翻转字符串里的单词 

        这道题的思路可以总结为以下三个步骤：

        ①、反转整个字符串

        ②、反转字符串中的每个单词

        ③、去除多余的空格

只要能想到这三个步骤，再分别对每个部分写代码就好了，不过代码其实不好写，需要多注意哦，给出的代码如下：

class Solution {
public:
    string reverseWords(string s) {
        //1、反转整个链表
        reverse(s.begin(), s.end());
        //2、反转每个单词
        int i = 0;
        while(i < s.size()) {
            while(i < s.size() && s[i] == ' ') {
                i++;
            }
            int cnt = 0;
            while(i < s.size() && s[i] != ' ') {
                cnt++;
                i++;
            }
            reverse(s.begin() + i - cnt, s.begin() + i);
        }
        //3、去除多余的空格
        int slow = 0;
        for(int fast = 0; fast < s.size(); ++fast) {
            if(s[fast] != ' ') {
                if(slow != 0)
                    s[slow++] = ' ';
            }
            while(fast < s.size() && s[fast] != ' ') {
                s[slow++] = s[fast++];
            }
        }
        s.resize(slow);
        return s;
    }
};

                   

第五题： 剑指Offer58-II.左旋转字符串 

        这道题很容易能想到重新创建一个空的string，然后按题目要求遍历s并添加到这个新建的string中就能得到答案。代码如下：

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        string result;
        for(int i = n; i < s.size(); ++i) {
            result += s[i];
        }
        for(int i = 0; i < n; ++i) {
            result += s[i];
        }
        return result;
    }
};

        看了题解之后，发现还可以不申请额外空间，在原先传入的字符串上操作就能解决这道题目，空间复杂度就从第一种方法的O(n)降低到了O(1).

        可以使用整体反转＋局部反转的思想来解题，先反转整个字符串，再分别对前后两个部分的子字符串进行反转，代码如下：

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        //1、首先反转整个字符串
        for(int l = 0, r = s.size() - 1; l < r; l++, r--) {
            swap(s[l], s[r]);
        }
        //2、之后分别反转前后两个部分的字串
        for(int l = 0, r = s.size() - n - 1; l < r; l++, r--) {
            swap(s[l], s[r]);
        }
        for(int l = s.size() - n, r = s.size() - 1; l < r; l++, r--) {
            swap(s[l], s[r]);
        }
        return s;
    }
};

Day8打卡！！！