【LeetCode】字符串精选9题

已于 2024-01-31 22:07:23 修改
阅读量902 收藏 21
点赞数 22
分类专栏： LeetCode精选算法题 文章标签： 算法 leetcode
于 2024-01-19 14:06:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qiuhan_909/article/details/134863477
版权

目录

基础题：

1. 最长公共前缀（简单）

滑动窗口：

1. 无重复字符的最长子串（中等）

2. 找到字符串中所有字母异位词（中等）

3. 串联所有单词的子串（困难）

4. 最小覆盖子串（困难）

回文串：

1. 验证回文串（简单）

2. 验证回文串 II（简单）

3. 回文子串（中等）

4. 最长回文子串（中等）

基础题：

1. 最长公共前缀（简单）

方法一：横向扫描

依次遍历字符串数组中的每个字符串，对于每个遍历到的字符串，更新最长公共前缀，当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀。

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        string ans = strs[0];
        for (int i = 1; i < strs.size(); i++)
        {
            ans = findCommon(ans, strs[i]);
        }
        return ans;
    }

private:
    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);
    }
};

方法二：纵向扫描

纵向扫描时，从前往后遍历所有字符串的每一列，比较相同列上的字符是否相同，如果相同则继续对下一列进行比较，如果不相同则当前列不再属于公共前缀，当前列之前的部分为最长公共前缀。

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        for (int j = 0; j < strs[0].size(); j++) // j表示列
        {
            char ch = strs[0][j];
            for (int i = 0; i < strs.size(); i++) // i表示行
            {
                if (j == strs[i].size() || strs[i][j] != ch)
                    return strs[0].substr(0, j);
            }
        }
        return strs[0];
    }
};

滑动窗口：

1. 无重复字符的最长子串（中等）

用滑动窗口定位子串，用哈希表记录子串中每个字符出现的次数。

进窗口后判断窗口中有没有重复字符，如果已经有重复字符了，要出窗口，直到没有重复字符。这时就找到了没有重复字符的子串，更新结果。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {        
        int n = s.size();
        int ans = 0;
        int left = 0;
        int right = 0;
        vector<int> hash(256, 0); // 下标表示ASCII码值
        while (right < n)
        {
            // 进窗口
            hash[s[right]]++;
            // 判断窗口中有没有重复字符
            while (hash[s[right]] > 1 && left <= right)
            {
                // 出窗口
                hash[s[left]]--;
                left++;
            }
            // 更新结果
            ans = max(ans, right - left + 1);
            // 更新右边界
            right++;
        }
        return ans;
    }
};

2. 找到字符串中所有字母异位词（中等）

字母异位词：

  • 长度相等
  • 每个字母出现的次数相等（可以用哈希表记录字符串中每个字母出现的次数）

暴力解法

用固定的p.size()大小的窗口定位s的子串，逐个扫描子串中的字母，并把字母在哈希表中对应的值-1，如果子串是p的排列，哈希表中所有的值为0。

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int nS = s.size();
        int nP = p.size();
        if (nS < nP)
            return {};

        vector<int> ans;
        vector<int> hash(26, 0); // hash[0]存储'a'出现的次数，hash[1]存储'b'出现的次数……
        for (auto& ch : p)
        {
            hash[ch - 'a']++;
        }

        int left = 0;
        int right = nP - 1;
        while (right < nS)
        {
            vector<int> tmp(hash);
            for (int i = left; i <= right; i++)
            {
                tmp[s[i] - 'a']--;
            }
            if (areAllZero(tmp))
            {
                ans.push_back(left);
            }
            left++;
            right++;
        }
        return ans;
    }

private:
    bool areAllZero(vector<int>& v)
    {
        for (auto& i : v)
        {
            if (i)
                return false;
        }
        return true;
    }
};

优化

用hash1记录字符串p中每个字母出现的次数，hash2记录字符串s的窗口中每个字母出现的次数。

用count记录窗口中有效字母的个数。窗口中的某一字母，它在窗口中出现的次数不能比它在p中出现的次数多，这就是有效字母。

进窗口的同时要维护count，然后判断窗口的大小是否> p.size()，如果已经> p.size()了，要出窗口并维护count，直到窗口的大小== p.size()。这时只能说明窗口的大小是合法的，不能说明窗口定位的子串一定是p的异位词。所以，接下来要判断有效字母的个数是否== p.size()，如果相等，说明找到了字母异位词，更新结果。

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int nS = s.size();
        int nP = p.size();
        if (nS < nP)
            return {};

        vector<int> ans;
        vector<int> hash1(26, 0); // 记录p中的字母出现的次数
        vector<int> hash2(26, 0); // 记录窗口中的字母出现的次数
        for (auto& ch : p)
        {
            hash1[ch - 'a']++;
        }

        int left = 0;
        int right = 0;
        int count = 0;
        while (right < nS)
        {
            // 进窗口+维护count
            char in = s[right];
            if (++hash2[in - 'a'] <= hash1[in - 'a']) // 判断有效字母
            {
                count++;
            }
            // 判断窗口大小是否>p.size()
            if (right - left + 1 > nP)
            {
                // 出窗口+维护count
                char out = s[left++];
                if (hash2[out - 'a']-- <= hash1[out - 'a']) // 判断有效字母
                {
                    count--;
                }
            }
            // 有效字母的个数==p.size()，说明找到了字母异位词，更新结果
            if (count == nP)
            {
                ans.push_back(left);
            }
            // 更新右边界
            right++;
        }
        return ans;
    }
};

3. 串联所有单词的子串（困难）

和“找到字符串中所有字母异位词”类似。区别在于：

  • 哈希表的key是字符串
  • 指针移动的步长是单词的长度len
  • 滑动窗口执行的次数是单词的长度len，见下图

暴力解法

用固定的words.size() * len大小的窗口定位s的子串，逐个扫描子串中的单词，并把单词在哈希表中对应的值-1，如果子串是words中的单词的排列，哈希表中所有的值为0。

暴力解法会超时，但是代码本身没有问题。

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        int nS = s.size(); // 字符串s的长度
        int nW = words.size(); // 数组words中单词的个数
        int len = words[0].size(); // 一个单词的长度
        if (nS < nW * len)
            return {};

        vector<int> ans;
        unordered_map<string, int> hash; // 记录words中单词出现的次数
        for (auto& s : words)
        {
            hash[s]++;
        }

        // 滑动窗口执行len次
        for (int i = 0; i < len; i++)
        {
            int left = i;
            int right = i + nW * len - 1;
            while (right < nS)
            {
                unordered_map<string, int> tmp(hash);
                for (int i = left; i <= right - len + 1; i += len)
                {
                    tmp[s.substr(i, len)]--;
                }
                if (areAllZero(tmp))
                {
                    ans.push_back(left);
                }
                left += len;
                right += len;
            }
        }
        return ans;
    }

private:
    bool areAllZero(unordered_map<string, int> ump)
    {
        for (auto& e : ump)
        {
            if (e.second)
                return false;
        }
        return true;
    }
};

优化

用hash1记录数组words中每个单词出现的次数，hash2记录字符串s的窗口中每个单词出现的次数。

用count记录窗口中有效单词的个数。窗口中的某一单词，它在窗口中出现的次数不能比它在words中出现的次数多，这就是有效单词。

进窗口的同时要维护count，然后判断窗口的大小是否> words.size() * len，如果已经> words.size() * len了，要出窗口并维护count，直到窗口的大小== words.size() * len。这时只能说明窗口的大小是合法的，不能说明窗口定位的子串一定是串联子串。所以，接下来要判断有效单词的个数是否== words.size()，如果相等，说明找到了串联子串，更新结果。

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        int nS = s.size(); // 字符串s的长度
        int nW = words.size(); // 数组words中单词的个数
        int len = words[0].size(); // 一个单词的长度
        if (nS < nW * len)
            return {};

        vector<int> ans;
        unordered_map<string, int> hash1; // 记录words中单词出现的次数
        for (auto& s : words)
        {
            hash1[s]++;
        }

        // 滑动窗口执行len次
        for (int i = 0; i < len; i++)
        {
            unordered_map<string, int> hash2; // 记录窗口中单词出现的次数
            int left = i;
            int right = i;
            int count = 0;
            while (right + len - 1 < nS)
            {
                // 进窗口+维护count
                string in = s.substr(right, len);
                hash2[in]++;
                if (hash1.count(in) && hash2[in] <= hash1[in]) // 判断有效单词
                {
                    count++;
                }
                // 判断窗口大小是否大于words.size()*len
                if (right + len - left > nW * len)
                {
                    // 出窗口+维护count
                    string out = s.substr(left, len);
                    if (hash1.count(out) && hash2[out] <= hash1[out]) // 判断有效单词
                    {
                        count--;
                    }
                    hash2[out]--;
                    left += len;
                }
                // 有效单词的个数==words.size()，说明找到了串联子串，更新结果
                if (count == nW)
                {
                    ans.push_back(left);
                }
                // 更新右边界
                right += len;
            }
        }
        return ans;
    }
};

4. 最小覆盖子串（困难）

暴力解法

用哈希表记录字符串t每个字符出现的次数。用滑动窗口定位s的子串，逐个扫描子串中的字符，并把字符在哈希表中对应的值-1。

如果哈希表中有值>0，说明子串没包含t的所有字符，则让右边界往右滑动，直到全部包含t的字符（哈希表中最终所有值都<=0）。

如果子串包含t的所有字符，则让左边界往右滑动，然后判断删除子串最左边的字符后是否仍然包含t的所有字符。

class Solution {
public:
    string minWindow(string s, string t) {
        int nS = s.size();
        int nT = t.size();
        if (nS < nT)
            return "";

        vector<int> hash(256, 0); // 下标表示ASCII码值
        for (auto& ch : t)
        {
            hash[ch]++;
        }

        int left = 0;
        int right = 0;
        int min = INT_MAX; // 最小子串长度
        int begin = -1; // 最小子串起始位置
        while (right < nS)
        {
            hash[s[right]]--;
            while (areAllNotMoreThanZero(hash)) // 子串包括t的所有字符
            {
                if (right - left + 1 < min)
                {
                    min = right - left + 1;
                    begin = left;
                }
                hash[s[left]]++;
                left++;
            }
            right++;
        }
        
        if (begin == -1)
            return "";
        else
            return s.substr(begin, min);
    }

private:
    bool areAllNotMoreThanZero(vector<int>& v)
    {
        for (auto& i : v)
        {
            if (i > 0)
                return false;
        }
        return true;
    }
};

优化

用hash1记录字符串t中每个字符出现的次数，hash2记录字符串s的窗口中每个字符出现的次数。

用kind记录t中的字符的种类。用count记录窗口中有效字符的种类。注意，是种类，和之前的题不一样！窗口中的某一字符，只有它在窗口中出现的次数 == 它在t中出现的次数时，才记录。

例如，

t = "ABCCC"，s = "ECDBACBCBD"

假设，红色表示的是左边界，蓝色表示的是右边界。现在正在进窗口：

ECDBACBCBD，E在窗口中出现1次，在t中出现0次

ECDBACBCBD，C在窗口中出现1次，在t中出现3次

ECDBACBCBD，D在窗口中出现1次，在t中出现0次。

ECDBACBCBD，B在窗口中出现1次，在t中出现1次，count++

ECDBACBCBD，A在窗口中出现1次，在t中出现1次，count++

ECDBACBCBD，C在窗口中出现2次，在t中出现3次

ECDBACBCBD，B在窗口中出现2次，在t中出现1次

ECDBACBCBD，C在窗口中出现3次，在t中出现3次，count++

此时窗口中有效字符的种类 == 字符串t中字符的种类，显然"ECDBACBC"涵盖了"ABCCC"的所有字符。

进窗口的同时要维护count，然后判断count是否== kind，如果相等，说明找到了覆盖子串，更新结果，然后出窗口并维护count，直到count < kind。

class Solution {
public:
    string minWindow(string s, string t) {
        int nS = s.size();
        int nT = t.size();
        if (nS < nT)
            return "";

        vector<int> hash1(256, 0); // 记录t中的字符出现的次数
        vector<int> hash2(256, 0); // 记录窗口中的字符出现的次数
        int kind = 0; // 记录t中的字符的种类
        for (auto& ch : t)
        {
            if (hash1[ch]++ == 0)
            {
                kind++;
            }
        }

        int left = 0;
        int right = 0;
        int count = 0;
        int min = INT_MAX; // 最小子串长度
        int begin = -1; // 最小子串起始位置
        while (right < nS)
        {
            // 进窗口+维护count
            char in = s[right];
            if (++hash2[in] == hash1[in])
            {
                count++;
            }
            // 判断count是否== kind
            while (count == kind)
            {
                // 找到了覆盖子串，更新结果
                if (right - left + 1 < min)
                {
                    min = right - left + 1;
                    begin = left;
                }
                // 出窗口+维护count
                char out = s[left++];
                if (hash2[out]-- == hash1[out])
                {
                    count--;
                }
            }
            right++;
        }
        
        if (begin == -1)
            return "";
        else
            return s.substr(begin, min);
    }
};

回文串：

1. 验证回文串（简单）

从两端向里逐个比较，跳过非字母数字字符，如果出现了不同的字符，则不是回文串。

class Solution {
public:
    bool isPalindrome(string s) {
        int left = 0; // 首指针
        int right = s.size() - 1; // 尾指针
        while (left < right)
        {
            while (!isalnum(s[left]) && left < right)
            {
                left++;
            }
            while (!isalnum(s[right]) && left < right)
            {
                right--;
            }
            int chLeft = tolower(s[left]);
            int chRight = tolower(s[right]);
            if (chLeft != chRight)
            {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
};

2. 验证回文串 II（简单）

从两端向里逐个比较，如果字符不相同，判断删除这两个字符的其中一个能否形成回文。

class Solution {
public:
    bool validPalindrome(string s) {
        int left = 0; // 首指针
        int right = s.size() - 1; // 尾指针
        while (left < right)
        {
            if (s[left] != s[right])
            {
                break;
            }
            left++;
            right--;
        }
        return left == s.size() / 2 || isPalindrome(s, left, right - 1) || isPalindrome(s, left + 1, right);
    }

private:
    bool isPalindrome(string s, int start, int end)
    {
        while (start < end)
        {
            if (s[start] != s[end])
            {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
};

3. 回文子串（中等）

枚举所有可能的回文中心，向两边拓展，形成回文子字符串。

回文长度是奇数，回文中心是一个字符；回文长度是偶数，回文中心是两个字符。

假设字符串长度为4，枚举所有可能的回文中心：

"abcd"

 0123

编号i回文中心左起始位置left回文中心右起始位置right
000
101
211
312
422
523
633

可以看出left = i/2，right = i/2 + i % 2，长度为n的字符串，一共有2n - 1个可能的回文中心。

class Solution {
public:
    int countSubstrings(string s) {        
        int n = s.size();
        int ans = 0;
        for (int i = 0; i < 2 * n - 1; i++)
        {
            int left = i / 2;
            int right = i / 2 + i % 2;
            while (left >= 0 && right < n && s[left] == s[right]) 
            {
                left--;
                right++;
                ans++;
            }
        }
        return ans;
    }
};

4. 最长回文子串（中等）

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        int pos = 0; // 最长回文子串的起始位置
        int len = 0; // 最长回文子串的长度
        for (int i = 0; i < 2 * n - 1; i++)
        {
            int left = i / 2;
            int right = i / 2 + i % 2;
            while (left >= 0 && right < n && s[left] == s[right]) 
            {
                left--;
                right++;
            }
            if (right - left - 1 > len)
            {
                pos = left + 1;
                len = right - left - 1;
            }
        }
        return s.substr(pos, len);
    }
};
秋秋晗晗
关注
专栏目录
Leetcode---常见字符串题型
sinat_40432588的博客
05-01 326
脑子秀逗的一道题 给定一个单词，你需要判断单词的大写使用是否正确。 我们定义，在以下情况时，单词的大写用法是正确的： 全部字母都是大写，比如"USA"。 单词中所有字母都不是大写，比如"leetcode"。 如果单词不只含有一个字母，只有首字母大写， 比如 “Google”。 否则，我们定义这个单词没有正确使用大写字母。 看着挺简单的一道题吧，然后我想到的是暴力求解-直接循环判断即可，啪啪啪写了大...
LeetCode 面试题 01.06. 字符串压缩
01-20
字符串压缩题目解题思路图解代码实现实现结果补充 面试题 01.06. 字符串压缩 题目来源：https://leetcode-cn.com/problems/compress-string-lcci 题目 字符串压缩。利用字符重复出现的次数，编写一种方法，实现...
LeetCode：字符串（7道经典题目）
一起加油~
03-31 2240
LeetCode字符串的一些经典题目，编程语言用的是C++和Python。
Leetcode经典题目----字符串
Java技术大联盟
08-16 450
1. 两个字符串包含的字符是否完全相同 242. Valid Anagram (Easy) s = “anagram”, t = “nagaram”, return true. s = “rat”, t = “car”, return false. 可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。 由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，不再使用 HashMap。 方法一： class Solution
[leetcode ~字符串]必刷经典题
程序员三木的博客
12-10 1163
其实在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。一些同学可能为了处理逻辑：每隔2k个字符的前k的字符，写了一堆逻辑代码或者再搞一个计数器，来统计2k，再统计前k个字符。给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。解释：如果两个单词间有多余的空格，颠倒后的字符串需要将单词间的空格减少到仅有一个。商业转载请联系官方授权，非商业转载请注明出处。
Leetcode字符串经典九道算法题（代码及解题思路）
云瀚的自习室
08-28 1795
此文章整理于2020年校招期间，当时刷了一部分Leetcode的算法题，拿到了一些大中厂的offer。字符串9道经典算法题的解题思路及代码整理如下。
LeetCode判断字符串是否循环-Leetcode:力码
07-01
LeetCode判断字符串是否循环 Leetcode 2017年4月12日 455 分蛋糕： 有g个孩子，s块蛋糕，每个孩子有一个贪心因子m，每块蛋糕可大可小n，若蛋糕大小n大于等于m，则可以分配这块蛋糕给这个孩子。每个孩子只能分得一块...
python leetcode 字符串相乘实例详解
12-25
给定两个以字符串形式表示的非负整数 num1 和 num2 ，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。 示例 1: 输入: num1 = "2", num2 = "3" 输出: “6” 示例 2: 输入: num1 = "123", num2 = "456" ...
LeetCode字符串换行-Leet-Code-May-Long-Challenge:Leetcode的Python解决方案可能面临挑战
06-30
LeetCode字符串换行力码五月挑战 Leet 代码的 Python 解决方案可能面临挑战。 第 1 天：第一个坏版本 第2天：珠宝和石头 第3天：赎金记录 Day4：补数 第 5 天：s 字符串中的第一个唯一字符 第6天：多数元素 第7天：...
leetcode-165-字符串经典算法题笔记
0117
09-23 338
其实题目的意思很直白，在正常的情况下，比较版本号，大家估计也就都懂了，而01和001转换成Integer的时候，实际都为1，这也就提示我们可以用split拆分之后，直接Integer.valueOf去比较大小就可以了。 特殊情况 ： 两个version的length不一样长，在正常遍历的时候会发生数组越界，就会报错了。 所以我们的难点就在于上面难点特殊情况上。 解决这个方法有两个方法： 最好理...
Leetcode刷题-字符串详细总结（Java）
Mikkkee的博客
04-09 1142
可以首先对。
LeetCode字符串经典题（一）
CodePanda@GPF的博客
06-04 439
LeetCode字符串题型
【leetcode刷题之路】面试经典150题（1）——数组/字符串
xtcc的博客
02-16 1595
新年第一更，祝大家都找到满意的offer！！！
【算法】LeetCode：字符串篇
知识输出、记录学习
11-04 895
代码随想录推荐：快速入门的刷题顺序（Java版）
leetcode 字符串题目集锦
xiangxianghehe的博客
08-26 4317
反转字符串leetcode 344 题目： 编写一个函数，其作用是将输入的字符串反转过来。 示例 1: 输入: &amp;amp;amp;quot;hello&amp;amp;amp;quot; 输出: &amp;amp;amp;quot;olleh&amp;amp;amp;quot; 示例 2: 输入: &amp;amp;amp;quot;A man, a plan, a canal: Panama&amp;amp;am
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 518
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
深⼊理解指针2
ElePower9527的博客
11-01 639
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
字符串-06-整数与ip地址之间的转换
最新发布
qq_45480682的博客
11-04 222
华为od算法——HJ33
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
weixin_47868976的博客
10-31 1086
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
leetcode 字符串左移
01-01
例如，对于字符串"leetcode"，经过一次左移操作后，得到的字符串为"eetcodel"。这种操作可以通过多种方法来实现，其中最简单的方法是使用字符串切片和拼接的方式来实现。具体来说，可以先将字符串按照指定的左移位数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值