【LeetCode字节专题】挑战字符串

打卡地址

无重复字符的最长子串（哈希表 + 双指针）

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // 解题思路 ： 哈希表 + 双指针
        unordered_map<char,int> hash;
        
        int res = 0;
        for(int i=0, j =0;i < s.size();i ++)
        {
            hash[s[i]] ++ ;
            while(hash[s[i]] > 1)
            {
                hash[s[j]] --;
                j ++;
            }
            res = max(res,i - j + 1);
        }
        
        return res;
    }
};

翻转字符串里的单词（双指针，stringstream）

算法1：翻转两次

class Solution {
public:
    string reverseWords(string s) {
        // 解题思路：翻转两次，第一次以单词翻转，第二次翻转整行
        int i = 0, k = 0;
        s += ' ';
        while(k < s.size() && s[k] == ' ') k ++; // 删除第一个单词前的空格
        while(k < s.size()) // 保留每个单词后只有一个空格
        {
            if(s[k] != ' ') s[i ++ ] = s[k ++ ];
            else 
            {
                s[i ++ ] = ' ';
                while(k < s.size() && s[k] == ' ') k ++ ;
            }
        }
        
        if(!i) // 没有这一行，下面删除行末空格会越界
        {
            s = "";
            return s;
        }
        s.erase(s.begin() + i - 1,s.end()); // 删除行末多余空格
        
        for(int i=0;i<s.size();i++)
        {
            int j = i;
            while(j < s.size() && s[j] != ' ') j ++; // 双指针算法计算每个单词的区间
            reverse(s.begin() + i ,s.begin() + j);
            i = j;
        }
        
        reverse(s.begin(),s.end());
        
        return s;
    }
};

算法2：利用stringstream流

class Solution {
public:
    string reverseWords(string s) {
        // 解题思路：先将每个单词存下来再翻转,利用stringstream
        vector<string> list;
        stringstream ssin(s);
        string t;
        while(ssin >> t) list.push_back(t);
        reverse(list.begin(),list.end());
        
        string res;
        for(int i=0;i<list.size();i++)
            if(i == list.size() - 1) res += list[i];
            else res += list[i] + " ";
        
        return res;
        
    }
};

字符串相乘(双高精度乘)

class Solution {
public:
    
    vector<int> get_num(string s)
    {
        vector<int> res ;
        for(int i = s.size() - 1;i>=0;i--) res.push_back(s[i] - '0'); // 高位在后,方便进位
        return res;
    }
    
    string get_string(vector<int> nums)
    {
        string res;
        for(int i = nums.size()-1;i >= 0;i--) res += to_string(nums[i]); // debug : i >= 0
        return res;
    }
    
     vector<int> mul(vector<int> &n1,vector<int> &n2) // 双高精度乘
     {
         vector<int> res(n1.size() + n2.size());
         for(int i=0;i<n1.size();i++)
            for(int j=0;j<n2.size();j++)
            {
                res[i + j] += n1[i] * n2[j];
            }
            
        
         for(int i=0;i<res.size() -1;i++) // 处理进位 debug : res.size() - 1,不然越界
         {
             res[i + 1] += res[i] / 10;
             res[i] %= 10;
         }
         while(res.size() > 1 && res.back() == 0) res.pop_back(); // 去除前导0

         return res;
     }
    
    string multiply(string num1, string num2) {
        vector<int> n1 = get_num(num1);
        vector<int> n2 = get_num(num2);
        
        vector<int> n3 = mul(n1,n2);
        
        return get_string(n3);
    }
};

最长公共前缀(遍历单词容器)

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if(strs.empty()) return "";
        string res = strs[0];
        for(int i=1;i<strs.size();i++)
        {
            for(int j = 0;j < res.size();j ++)
                if(res[j] != strs[i][j])
                {
                    res.erase(res.begin() + j,res.end());
                    if(res == "") return res;
                    break;
                }
        }
        return res;
    }
};

字符串的排列(滑动窗口 + 枚举)

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        int n = s1.size(), m = s2.size();
        vector<int> st(26,0), cur(26,0);
        for(auto c : s1) st[c - 'a'] ++;
    
        for(int i=0;i<m;i++)
        {
            cur[s2[i] - 'a'] ++;
            if(i >= n - 1)
            {
                bool check = true;
                for(int j=0;j<26;j++)
                {
                    if(st[j] != cur[j]){
                        check = false;
                        break;
                    }
                }
                if(check) return true;
                cur[s2[i - n + 1] - 'a'] --;
            }
            
        }
        
        return false;
    }
};