Leetcode分类刷算法之字符串专题

最新推荐文章于 2023-01-19 18:28:21 发布
最新推荐文章于 2023-01-19 18:28:21 发布
阅读量241 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： leetcode 字符串 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41927235/article/details/103684405
版权

leetcode 字符串问题

先来几个题目热热身

1. leetcode 709. 转换成小写字母

709. 转换成小写字母

a - 32 = A;

public String toLowerCase(String str) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if ( c >= 'A' && c <= 'Z') {
                c += 32;
            }
            sb.append(c);
        }
        return sb.toString();
    }

2. leetcode 58. 最后一个单词的长度

58. 最后一个单词的长度

public int lengthOfLastWord(String s) {
        int res = 0;
        for (int i = s.length() - 1; i >= 0; i--){
            if (s.charAt(i) != ' '){
                res++;
            }else if (res != 0){
                return res;
            }
        }
        return res;
    }

3. leetcode 771. 宝石与石头

771. 宝石与石头

public int numJewelsInStones(String J, String S) {
        int[] cache = new int[128];
        int count = 0;
        char[] c1 = J.toCharArray();
        char[] c2 = S.toCharArray();
        for (char i : c1) {
            cache[i] = 1;
        }
        for (char i : c2) {
            if (cache[i] == 1){
                count++;
            }
        }
        return count;
    }

4. leetcode 387. 字符串中的第一个唯一字符

387. 字符串中的第一个唯一字符

public int firstUniqChar(String s) {
        int[] cache = new int[26];
        for(int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if (c >= 'a' && c <= 'z'){
                cache[c - 'a']++;
            }
        }
        for(int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if (cache[c - 'a'] == 1){
                return i;
            }
        }
        return -1;
    }

5. leetcode 8. 字符串转换整数 (atoi)

8. 字符串转换整数 (atoi)

￥￥￥￥￥

public int myAtoi(String str) {
        str = str.trim();
        if (str == null || str.length() == 0)return 0;

        char first = str.charAt(0);
        int sign = 1;
        int start = 0;
        long res = 0;
        if (first == '+'){
            start++;
        }else if (first == '-'){
            sign = -1;
            start++;
        }
        for (int i = start; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return (int) res * sign;
            }
            res = res * 10 + str.charAt(i) - '0';
            if (sign == 1 && res > Integer.MAX_VALUE)return Integer.MAX_VALUE;
            if (sign == -1 && res > Integer.MAX_VALUE)return Integer.MIN_VALUE;
        }
        return (int)res * sign;
    }

6. leetcode 14. 最长公共前缀

14. 最长公共前缀

public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0)return "";
        for (int i = 0; i < strs[0].length(); i++) {
            char c = strs[0].charAt(i);
            for(int j = 1; j < strs.length; j++){
                if (i == strs[j].length() || strs[j].charAt(i) != c){
                    return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];
    }

7. leetcode 541. 反转字符串 II

541. 反转字符串 II

 public String reverseStr(String s, int k) {
        char[] c = s.toCharArray();
        int len = s.length();
        for (int i = 0; i < len; i = i + 2 * k) {
            if (i + 2 * k <= len || i + k <= len){
                swap(c,i,i + k -1);
            }else{
                swap(c, i , len - 1);
            }
        }
        return new String(c);
    }

    public void swap(char[] s, int left,int right) {
        while(left < right){
            s[left] ^= s[right];
            s[right] ^= s[left];
            s[left] ^= s[right];
            left++;
            right--;
        }
    }

8. leetcode 151. 翻转字符串里的单词

151. 翻转字符串里的单词

public String reverseWords(String s) {
       String[] s1 = s.trim().split(" ");
       StringBuilder sb = new StringBuilder();
       for (int i = s1.length - 1; i >= 0; i--) {
           String str = s1[i];
           while (str.contains(" ")) {//有可能是两个空格在一起"a good   example"
               str.replaceAll(" ","");
           }
           if("".equals(str)){ 
               continue;
           }
           sb.append(str);
           if (i != 0){
               sb.append(" ");
           }
       }
       return sb.toString();
    }

异位词问题

9. leetcode 242. 有效的字母异位词

242. 有效的字母异位词

public boolean isAnagram(String s, String t) {
        if (s == null || t == null || s.length() != t.length()) {
            return false;
        }
        int[] count = new int[26];
        for (int i = 0; i < s.length(); i++){
            count[s.charAt(i) - 'a']++;
        }

        for (int i = 0; i < t.length(); i++){
            count[t.charAt(i) - 'a']--;
        }
        for (int i : count) {
            if (i != 0)return false;
        }
        return true;
    }

10. leetcode 49. 字母异位词分组

49. 字母异位词分组

public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, ArrayList<String>> map = new HashMap<>();
        for(String s : strs) {
            char[] ch = s.toCharArray();
            Arrays.sort(ch);
            String key = new String(ch);
            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<String>());
            }
            map.get(key).add(s);
        }
        return new ArrayList(map.values());
    }

11. leetcode 438. 找到字符串中所有字母异位词

438. 找到字符串中所有字母异位词

时间复杂度很高

public List<Integer> findAnagrams(String s, String p) {
        char[] key = p.toCharArray();
        Arrays.sort(key);
        String value = new String(key);
        List<Integer> res = new ArrayList<>();
        for (int i = 0 ; i < s.length() - p.length() + 1 ; i++){
            String str = s.substring(i, i + p.length());
            char[] ch = str.toCharArray();
            Arrays.sort(ch);
            String newStr = new String(ch);
            if (newStr.equals(value)) {
                res.add(i);
            }
        }
        return res;
    }

labuladong大佬总结的滑动窗口通用思想解决字串问题

 //窗口长度为p ，比较每个窗口是否与p是字母异位词 用字典法比较
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> res = new ArrayList<>();
        if (s.length() < p.length())return res;

        int[] dict = new int[26];
        for (char c : p.toCharArray()) {
            dict[c - 'a']++;
        }
        int[] cur = new int[26];
        for (int i = 0; i < p.length() - 1; i++) {
            cur[s.charAt(i) - 'a']++;
        }

        for (int i = p.length() - 1; i < s.length(); i++) {
            cur[s.charAt(i) - 'a']++; 
            if (isAnagrams(dict,cur)) { //行成窗口 如果是异位词的话
                res.add(i - p.length() + 1);       
            }
            cur[s.charAt(i - p.length() + 1) - 'a']--;   //是与不是 都要更新窗口的左边界 维持窗口的大小为p.length();  
        }
        return res;
    }

    private boolean isAnagrams(int[] dict, int[] cur) {
        for (int i = 0; i < 26; i++) {
            if (dict[i] != cur[i])return false;
        }
        return true;   
    }

回文串问题

11. leetcode 125. 验证回文串

125. 验证回文串

public boolean isPalindrome(String s) {
        if(s == null) return true;
        s = s.toLowerCase();
        int l = s.length();
        StringBuilder sb = new StringBuilder();
        for(char c : s.toCharArray()){
            if((c >= '0'&& c <= '9') || (c >= 'a' && c <= 'z')){
                sb.append(c);
            }
        }
        s = sb.toString();
        int start = 0;
        int end = s.length()-1;
        while (start < end) {
            if (s.charAt(start) != s.charAt(end)) {
                return false;
            }
            start++;
            end--;
        }
        return true;    
    }

原地算法过滤出有效字符 再进行判断是否回文

 public boolean isPalindrome(String s) {
        char[] ch = s.toCharArray();
        int index =0;
        int left = 0;
        for (int i = 0; i < s.length(); i++) {
            if (('0' <= ch[i] && ch[i] <='9') || ('a' <= ch[i] && ch[i]  <= 'z')) {
                ch[index++] = ch[i];
            }else if ('A' <= ch[i] && ch[i] <= 'Z') {
                ch[index++] = (char)(ch[i] - 'A' + 'a');
            }
        }
        index--;
        while(left < index) {
            if (ch[left++] != ch[index--])return false;
        }
        return true;
    }

12. leetcode 680. 验证回文字符串 Ⅱ

680. 验证回文字符串Ⅱ

public boolean validPalindrome(String s) {
        for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return isPalindrome(s,i + 1, j) || isPalindrome(s, i, j - 1);
            }
        }
        return true;
    }

    private boolean isPalindrome(String s, int i, int j) {
        while (i < j) {
            if (s.charAt(i++) != s.charAt(j--))return false;
        }
        return true;
    }

字符串 + DP

13. leetcode 5. 最长回文子串

5. 最长回文子串

dp[start][end]表示从start到end是否是回文串

public String longestPalindrome(String s) {
       int len = s.length();
       if (len <= 1)return s;
       int longestLength = 0;
       boolean[][] dp = new boolean[len][len];
       String res = s.substring(0, 1);
       for (int end = 0; end < len; end++) {
           for(int start = 0; start <= end; start++) {
               if(start == end) {
                   dp[start][end] = true;
               }else {
                   if(s.charAt(end) == s.charAt(start) && (end - start <= 1 || dp[start + 1][end - 1])){
                       dp[start][end] = true;
                       if (end - start + 1 > longestLength) {
                           longestLength = end - start + 1;
                           res = s.substring(start, end + 1);
                       }
                   }
               }
           }
       }
       return res;
    }

14. leetcode 1143. 最长公共子序列

1143. 最长公共子序列

(1) 如果S的最后一位等于T的最后一位，则最大子序列就是{s1,s2,s3…si-1}和{t1,t2,t3…tj-1}的最大子序列+1

(2) 如果S的最后一位不等于T的最后一位，那么最大子序列就是

① {s1,s2,s3…si}和 {t1,t2,t3…tj-1} 最大子序列

② {s1,s2,s3…si-1}和{t1,t2,t3…tj} 最大子序列

public int longestCommonSubsequence(String text1, String text2) {
        int dp[][] = new int[text1.length() + 1][text2.length() + 1];
        for (int i = 1; i <= text1.length(); i++) {
            for (int j = 1; j <= text2.length(); j++) {
                if(text1.charAt(i - 1) == text2.charAt(j - 1)){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else{
                    dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }

15. leetcode 72. 编辑距离

72. 编辑距离

public int minDistance(String word1, String word2) {
        if (word1 == null || word2 == null)return 0;
        int m = word1.length();
        int n = word2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= n; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                }else {
                    dp[i][j] = Math.min(dp[i - 1][j - 1] , Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;
                }
            }
        }
        return dp[m][n];
    }

16. leetcode 76. 编辑距离

76. 最小覆盖子串
滑动窗口解法

public String minWindow(String s, String t) { 
    Map<Character, Integer> map = new HashMap<>();
    //遍历字符串 t，初始化每个字母的次数
    for (int i = 0; i < t.length(); i++) {
        char char_i = t.charAt(i);
        map.put(char_i, map.getOrDefault(char_i, 0) + 1);
    }
    int left = 0; //左指针
    int right = 0; //右指针
    int ans_left = 0; //保存最小窗口的左边界
    int ans_right = -1; //保存最小窗口的右边界
    int ans_len = Integer.MAX_VALUE; //当前最小窗口的长度
    //遍历字符串 s
    while (right < s.length()) {
        char char_right = s.charAt(right);
        //判断 map 中是否含有当前字母
        if (map.containsKey(char_right)) {
            //当前的字母次数减一
            map.put(char_right, map.get(char_right) - 1);
            //开始移动左指针，减小窗口
            while (match(map)) { //如果当前窗口包含所有字母，就进入循环
                //当前窗口大小
                int temp_len = right - left + 1;
                //如果当前窗口更小，则更新相应变量
                if (temp_len < ans_len) {
                    ans_left = left;
                    ans_right = right;
                    ans_len = temp_len;
                }
                //得到左指针的字母
                char key = s.charAt(left);
                //判断 map 中是否有当前字母
                if (map.containsKey(key)) {
                    //因为要把当前字母移除，所有相应次数要加 1
                    map.put(key, map.get(key) + 1);
                }
                left++; //左指针右移
            }
        }
        //右指针右移扩大窗口
        right++;
    }
    return s.substring(ans_left, ans_right+1);
}

//判断所有的 value 是否为 0
private boolean match(Map<Character, Integer> map) {
    for (Integer value : map.values()) {
        if (value > 0) {
            return false;
        }
    }
    return true;
}

17. leetcode 3. 无重复字符的最长子串

3. 无重复字符的最长子串

滑动窗口的解法，当出现重复的时候判断左边界的值是否与当前右边界重复

 public int lengthOfLongestSubstring(String s) {
        if (s == null || s.length() == 0) return 0;
        int left = 0, right = 0;
        int res = 0;
        int[] dict = new int[256];
        while (right < s.length()) {
            char c = s.charAt(right);
            dict[c]++;
            right++;
            while (dict[c] > 1) { //直到去掉重复的字符；
                char c1 = s.charAt(left);
                dict[c1]--;
                left++; 
            }
            res = Math.max(res, right - left);
        }
        return res;
    }

18. leetcode 44. 通配符匹配

44. 通配符匹配
参考题解

dp数组的含义：dp[i][j]意思是s的前i个元素能否被p的前j个元素成功匹配。
知道了dp数组的含义之后，我们就知道了初始化细节：
boolean类型的dp数组，大小是[s.length+1][p.length+1]，因为存在s前0个字符和p前0个字符的情况。
dp[0][0]一定是true，因为s空串和p空串是可以匹配成功的；dp[1][0]~dp[s.length][0]一定都是false，因为s不为空串而p为空串是不能匹配成功的。
dp[0][1]~dp[0][p.length]当s为空串的时候，而p不是空串的时候，当且仅当p的j字符以及前面都为’‘才为true。
dp[s.length][p.length]就得到了s和p最终的匹配情况。
有了上述理解之后，就可以初始化dp数组了。
然后填写dp数组剩余部分即可，状态转移方程：
当s[i]p[j]或者p[j]’?’，则dp[i][j]=dp[i-1][j-1]。可以理解为当前字符成功匹配后，只需要考虑之前的字符串是否匹配即可；也可以理解为当前字符匹配成功之后，"移除"当前元素(即不需要再考虑当前元素)。
当p[j]==’’，则dp[i][j]=dp[i-1][j]||dp[i][j-1]。可以理解为当字符为’‘的时候会出现两种情况，第一种是’‘需要作为一个字母与s[i]进行匹配；第二种是’‘需要作为空字符(即不需要’‘可以直接"移除")，所以dp[i][j-1]；用逻辑或将两种情况连接，是因为只要有一种情况可以匹配成功则当前匹配成功，有点暴力算法的感觉。
最后当s[i]!=p[j]&&p[j]!=’*’，dp[i][j]=false。这步可以省略，因为dp数组元素的默认值就是false，所以不必要进行显式的赋值为false。

public boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();
        boolean[][] dp = new boolean[m + 1][n + 1];
        dp[0][0] = true;
        for (int i = 1; i <= n; i++) {
            dp[0][i] = dp[0][i - 1] && p.charAt(i - 1) == '*';
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '?') {
                    dp[i][j] = dp[i - 1][j - 1];
                }
                if (p.charAt(j - 1) == '*') {
                    dp[i][j] = dp[i][j - 1] || dp[i - 1][j]; 
                }
            }
        }
        return dp[m][n];
    }
别找我打球了
关注
专栏目录
LeetCode 所有算法类型总结
leetcode 解题思路
07-09 4711
BFS 到 Level Order traversal 到 Union Find 到 Topological Sort 到 Dijkstra 思路总结 Topological Sort 一篇 Dijkstra 一篇 Union Find 总结 一篇 Sorting (Merge Sort, Rainbow Sort, quick select) 一篇 Find Kth题目类型一篇 PreOrder, InOrder, PostOrder 题型总结一篇 Tree的Traverse and div
LeetCode 题型归类
xiaopengyou5的博客
10-10 549
1.几个数的求和问题     https://leetcode.com/problems/two-sum/description/
LeetCode刷题|算法归类|回溯算法介绍及各算法题合辑（持续补充）
weixin_45759791的博客
07-19 216
一、算法介绍 回溯算法就是把问题的解空间转化为图或树的结构表示，然后使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。 基本思想类同于：图的深度优先搜索和二叉树的后序遍历 详细的描述则为： 回溯法按深度优先策略搜索问题的解空间树。首先从根节点出发搜索解空间树，当算法搜索至解空间树的某一节点时，先利用剪枝函数判断该节点是否可行（即能得到问题的解）。如果不可行，则跳过对该节点为根的子树的搜索，逐层向其祖先节点回溯；否则，进入该子树，继续按深度优先策略搜索。 回溯法的基本行为是搜索，搜索过
LeetCode 2157. 字符串分组
英雄哪里出来
03-23 897
状态压缩好题
LeetCode分类刷题----字符串篇
池鱼
01-19 1287
双指针法，先统计空格的个数，然后给原字符串扩充空格*2的字符长度，然后left指针指向原字符串最后一个，right指针指向扩充后的字符串最后一个，当left指针遇到空格的时候，right指针存入%20即可，如果是正常字符则存入正常字符。用两个指针，快指针一直往后走，当它遇到不是空字符串的时候，就在慢指针里填充，注意每个单词之间要保证有一个空格。将原来的字符串拼接起来，然后删去头一个字母和最后一个字母，判断剩下的字符串是否还包含原来的字符串，如果包含的话就符合题意，如果不包含就不符合题意。
js-leetcode题解之验证回文字符串-题解.zip
最新发布
05-09
本题解集中关注的是“验证回文字符串”这个经典问题，这是一个基础但又实用的算法题目，对于JavaScript开发者来说是必备的技能之一。 **回文字符串**是指一个字符串，无论从左向右读还是从右向左读，其字符顺序都是...
js-leetcode题解之字符串字符最短路径-题解.zip
05-09
"js_leetcode题解之字符串字符最短路径_题解"这份资源包含了用JavaScript解答LeetCode上的一道关于字符串字符最短路径的问题。它涉及了字符串处理、动态规划或回溯法等关键概念，对于想要提升JavaScript算法能力的...
leetcode中DFS与BFS算法在数组和字符串中的应用
12-20
在编程领域，DFS（深度优先遍历）和BFS（广度优先遍历）是两种常用的图和树的遍历算法。它们的核心在于探索数据结构...理解这两种算法的精髓，并能灵活应用于数组和字符串等非传统树形结构，是提升编程技能的重要一步。
算法修炼之路—【字符串】Leetcode 345 反转字符串中的元音字母
12-20
在算法修炼之路上，我们经常会遇到各种有趣的编程挑战，其中之一便是LeetCode的第345题——反转字符串中的元音字母。本题目的目标是设计一个函数，接收一个字符串作为输入，然后仅反转其中的元音字母。元音字母包括...
LeetCode判断字符串是否循环-leetcode:leetcode练习，算法部分！
07-01
LeetCode判断字符串是否循环 leetcode leetcode exercises,algorithms part! TwoSum: 1.key point: unorderd_map(16ms), map(24ms) 2.大概是前50%的样子，并不知道如何进一步提升性能 addTwoNums: 1.新建ListNode...
Leetcode算法——49、字符串分组（group anagrams）
HappyRocking的专栏
12-04 2301
给定一个字符串数组，将所有字符串分组，每一组的字符串包含的字符相同但是顺序不同。 示例： 输入: ["eat", "tea", "tan", "ate", "nat", "bat"], 输出: [ ["ate","eat","tea"], ["nat","tan"], ["b
leetcode刷题源码（分类整理）
知行_那片天
02-10 1763
leetcode刷题大全（备战春招的请自提） 关键词：leetcode，刷题，源码，大全，春招， 秋招 分类整理，持续更新中 之前刷了不少leetcode的题目，现在开始春招了，特地把之前写的代码上传了github：https://github.com/czy36mengfei/leetcode，欢迎大家下载、star。 我刷leetcode比较按至少体系去刷，因为这样可以总结各类算法的特点和思想...
LeetCode分类总结
他的博客
06-05 5558
链表 树 二叉树的遍历 二叉树的构建 二叉查找树 二叉树的递归
Leetcode算法题分类解析：(一)总览
热门推荐
西代零零发
06-17 1万+
Leetcode算法题分类解析：(一)总览1.为何/如何刷题1.1 必要性刷题刷题，从“刷”字就能看出其中的机械性和应试性，但这就是几乎所有IT公司面试中的一环。尽管面试者可能也对这种考察方式不是很满意，可在没有更好的方式之前，这个现状会一直保持下去。我们改变不了这个现状，那就适应它吧。1.2 分类攻破为什么要这么麻烦地分类呢？照着Leetcode的题目顺序做不就好了？个人觉得分类有几个动机： 一是
【算法】字符串分类
华仔的逆袭的专栏
03-25 2033
题目：字符串分类，两个字符串A和B属于同一类需要满足以下条件： A中交换任意位置的两个字符，最终可以得到B，交换的次数不限。比如：abc与bca就是同一类字符串。 输入：首先输入一个正整数N（1 <= N <= 50），接下来输入N个字符串 输出：输出一个整数表示分类的个数。 例子： 3 abc bca cab 1 解题要点：需要抓住同类字符串的共同点（含有
leetcode分类总结
Zuoerfeng
11-09 2106
工作时间还刷了一点leetcode，发现了一篇好的博客，对leetcode的题目进行分类总结，按照博客的分类总结，可以更好的理解算法的切入点。 一些笔记（原博客链接）： http://note.youdao.com/noteshare?id=d3f79c6ccb9ea9c64edd0484dfa2e771 ...
Leetcode分类解析：组合算法
西代零零发
07-04 8093
Leetcode分类解析：组合算法所谓组合算法就是指：在解决一些算法问题时，需要产生输入数据的各种组合、排列、子集、分区等等，然后逐一确认每种是不是我们要的解。从广义上来说，组合算法可以包罗万象，甚至排序、各种搜索算法都可以算进去。最近读《The Algorithm Design Manual》时了解到这种归类，上网一查，甚至有专门的书籍讲解，而且Knuth的巨著TAOCP的第四卷就叫组合算法，看来
leetcode算法总结 —— HOT 100分类整理
Charles Ren's Tech Blog
04-01 8669
两数之和 二叉树的序列化与反序列化 最小栈 二叉树的最大深度（后序遍历深度向上返回）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值