【算法专题】字符串

1. 最长公共前缀

14. 最长公共前缀 - 力扣（LeetCode）

        本题要求我们找出最长的公共前缀，首先能想到的就是两两比较字符串，每次比较都找出最长公共前缀，当遍历完字符串数组后，我们就能够得到这个字符串数组的最长公共前缀了。还有一种做法就是以某个字符串为基准去统一比较其他字符串，比较过程中，当其他字符串长度小于这个基准或不等于这个基准时，说明这就是这个字符串数组的最长公共前缀。

        所以说这道题的思路并不难想，重点在于如何将思路转化为代码。

解法一：

string FindCommon(string &s1, string &s2)
    {
        int i = 0;
        while(i < min(s1.size(), s2.size()) && s1[i] == s2[i]) i++;
        return s1.substr(0, i);
    }
    string longestCommonPrefix(vector<string>& strs) 
    {
        // 解法一: 两两比较字符串
        string ret = strs[0];
        for(int i = 1; i < strs.size(); i++)
        {
            ret = FindCommon(ret, strs[i]);
        }
        return ret;
    }

解法二

class Solution {
public:
    // 解法二，统一比较
    string longestCommonPrefix(vector<string>& strs) 
    {
        for(int i = 0; i < strs[0].size(); i++)
        {
            char tmp = strs[0][i];
            for(int j = 1; j < strs.size(); j++)
            {
                if(i == strs[j].size() || strs[j][i] != tmp)
                {
                    return strs[0].substr(0, i);
                }
            }
        }
        return strs[0];
    }
};

2. 二进制加法

LCR 002. 二进制求和 - 力扣（LeetCode）

        本题的题目描述非常简单，就是给定两个二进制的字符串，实现二进制加法。这和我们在链表专题中，我们做过的两数相加实际上思路是类似的，我们同时从字符串末端开始遍历两个字符串，并把两个数和进位相加的结果存在变量t中，则由于是二进制加法，本位就是t%2，进位则是t/2，当遍历到其中一个字符串结束时，加零即可。

class Solution {
public:
    string addBinary(string a, string b) 
    {
        string ret;
        int cur1 = a.size() - 1, cur2 = b.size() - 1, t = 0;
        while(cur1 >= 0 || cur2 >= 0 || t > 0)
        {
            if(cur1 >= 0) t += a[cur1--] - '0';
            if(cur2 >= 0) t += b[cur2--] - '0';
            ret += t % 2 + '0';
            t /= 2;
        }
        reverse(ret.begin(), ret.end());
        return ret;
    }
};

3. 字符串解码

394. 字符串解码 - 力扣（LeetCode）

        依据题意，我们需要将括号内的字符串重复括号前的数字对应的遍数，并且还需要处理嵌套问题，如示例2：我们需要先将c重复两遍后，整个括号内的字符串重复三遍。对于括号内的括号，尽管它是之后出现的，我们需要进行优先处理，由于这一特点，我们不难想到可以尝试用栈来解决这个问题，因为栈的特性就是后进先出。

        于是问题就转化为了：栈里面要储存什么，什么时候入栈，什么时候出栈。因为我们需要将括号内的字符串重复括号前的数字对应的遍数，所以我们可以用一个栈储存数字，一个栈储存字符串。当遇到数字时，将元素压入数字栈；当遇到字符串时，将元素压入字符串栈；遇到左括号时，将一个空字符串压入字符串栈，这是因为左括号的下一个元素可能是：数字、字符串、左括号，我们需要保证将括号内的整个字符串提取出来后进行重复；遇到右括号时，数字栈弹出栈顶数字cnt，字符串栈弹出栈顶字符串，将栈顶字符串重复cnt次后，加入到新的栈顶元素中。

        除此之外，还有一个细节问题，如果我们一开始就需要对字符串进行解码，而此时字符串栈中并没有元素可以让重复后的字符串加入，就会造成越界访问，所以我们需要在一开始就往字符串栈中加入一个空的字符串来避免这种情况。

class Solution {
public:
    string decodeString(string s) 
    {
        vector<int> intSt;
        vector<string> strSt;
        strSt.push_back(""); // 处理一开始就要解码的情况
        int i = 0, n = s.size();
        while(i < n)
        {
            if(s[i] >= '0' && s[i] <= '9')
            {
                int tmp = 0;
                while(i < n && s[i] >= '0' && s[i] <= '9') // 处理数字不止一位的情况
                    tmp = tmp * 10 + (s[i++] - '0');
                intSt.push_back(tmp);
            }
            else if(s[i] >= 'a' && s[i] <= 'z') 
            {
                string tmp;
                while(i < n && s[i] >= 'a' && s[i] <= 'z') // 提取出整个字符串
                    tmp += s[i++];
                strSt.back() += tmp;
            }
            else if(s[i] == '[') // 跳过左括号继续看后面的元素是什么
            {
                i++;
                strSt.push_back("");
            }
            else if(s[i] == ']')
            {
                int cnt = intSt.back();
                intSt.pop_back();
                string tmp = strSt.back();
                strSt.pop_back();
                while(cnt--)
                {
                    strSt.back() += tmp; // 这一步为什么会越界访问？？？ ---- 开始没有插入空字符串！！！
                }
                i++;
            }
        }
        return strSt.back();
    }
};