备战sp23春招 day8 | 344.反转字符串 541. 反转字符串II 剑指 05.替换空格 151.翻转字符串里的单词 剑指58-II.左旋转字符串

344 反转字符串

class Solution {
public:
    void reverseString(vector<char>& s) {
        int n = s.size();
        int l = 0;
        int r = n - 1;
        while(l < r) {
            char tmp = s[r]; 
            s[r] = s[l];
            s[l] = tmp;
            l++;
            r--;
        }
    }
};

541 反转字符串2

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.size();
        int remain = n % (2*k);
        int gen = n/(2*k);
        for(int i = 0; i < gen; i++) {
            int l = i * 2 * k;      
            int r = i * 2 * k + k - 1;
            reverse(l,r,s);
        }
        if (remain < k) {
            reverse(n - remain,n - 1,s);
        } else if (remain < 2 * k) {
            reverse(n - remain,n - remain + k - 1,s);
        }
        return s;
    }

    void reverse(int l, int r, string& a) {
         while (l < r) {
                swap(a[r--],a[l++]);
        }
    }
};

剑指 05.替换空格

题目很简单 但是所求出的并不是最优解 我原本的解法

class Solution {
public:
    string replaceSpace(string s) {
        string ans = "";
        for (char c:s) {
            if (c == ' ') {
                ans += "%20";
            }
            else {
                ans.push_back(c);
            }
        }
        return ans;
    }
};

这样做的时间复杂度为o(n) 空间负责度为O(n)
然而，通过双指针从后向前填充元素即可以更加节省空间
从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。

• 其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作

class Solution {
public:
    string replaceSpace(string s) {
        int count = 0;
        for(char c:s) {
            if (c == ' ') {
                count++;
            }
        }
        int osize = s.size();
        s.resize(osize + 2*count);
        int nsize = s.size();
        for(int i = osize - 1, j = nsize - 1;i >= 0 && j >=0 ;i--,j--) {
                if (s[i] != ' ') {
                    s[j] = s[i];
                }
                else {
                    s[j] = '0';
                    s[j - 1] = '2';
                    s[j - 2] = '%';
                    j-= 2;
                }
        }
        return s;
    }
};

该做法的空间复杂度为O(1)

剑指58-II.左旋转字符串

O(1)空间解法 时间复杂度为O(n)

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        int sz = s.size();
        reverse(s, 0, sz - 1);
        reverse(s, 0, sz-1-n);
        reverse(s, sz-n, sz-1);
        return s;
    }

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