算法必刷系列之字符串

最新推荐文章于 2024-08-04 23:03:31 发布
最新推荐文章于 2024-08-04 23:03:31 发布
阅读量477 收藏 8
点赞数 15
分类专栏： 算法必刷系列 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45362454/article/details/134629914
版权

字符串

字符串虽然不是一种数据结构，在确是被经常使用的，与之相关的算法诸如字符串转换，计数、反转、压缩等问题是非常常见的

转换成小写字母

leetcode709
利用大小写字母Ascii码相差32对底层字符数组进行加减实现字符串转换

public String toLowerCase(String s) {
    int n = s.length();
    char[] chars = s.toCharArray();
    for (int i = 0; i < n; i++) {
        if (chars[i]>='A'&&chars[i]<='Z'){
            chars[i] += 32;
        }
    }
    String str = new String(chars);
    return str;
}

字符串转数字

leetcode8
按照题目要求，去掉空白字符，设置符号位，转换时，取数字，对原结果✖️10➕当前数字，注意溢出判断

public int myAtoi(String s) {
    int n = s.length();
    char[] chars = s.toCharArray();
    int sign = 1;
    int res = 0;
    int index = 0;
    while (index < n && chars[index] == ' ') {
        index++;
    }
    if (index == n) {
        return res;
    }
    if (chars[index] == '+') {
        index++;
    }else if (chars[index] == '-') {
        sign = -1;
        index++;
    }
    while (index < n) {
        if (chars[index] >= '0' && chars[index] <= '9') {
            if (res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && (chars[index]-'0') > Integer.MAX_VALUE % 10)) {
                return Integer.MAX_VALUE;
            }
            if (res < Integer.MIN_VALUE / 10 || (res == Integer.MIN_VALUE / 10 && (chars[index]-'0') > -(Integer.MIN_VALUE % 10))) {
                return Integer.MIN_VALUE;
            }
            res = res * 10 + sign * (chars[index] - '0');
            index++;
        } else {
            return res;
        }
    }
    return res;
}

原地反转字符串

leetcode344
使用双指针，对底层字符数组反转实现字符串的反转

public void reverseString(char[] s) {
    int left = 0;
    int right = s.length - 1;
    while (left < right){
        char c = s[left];
        s[left] = s[right];
        s[right] = c;
        left++;
        right--;
    }
}

K个一组反转字符串

leetcode541
与原地反转字符串基本相同，差别在于每次对2*k长度的子串进行操作，反转前K个，注意下标

public String reverseStr(String s, int k) {
    char[] chars = s.toCharArray();
    int length = s.length();
    for (int i = 0; i <= length; i+=2*k) {
        int left = i;
        int right = left + k-1;
        right = Math.min(right,length-1);
        swap(chars,left,right);
    }
    return new String(chars);
}

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

仅反转英文字母

leetcode917
使用双指针，分别从左到右和从右到左寻找英文字母，找到后进行交换，直至两指针重合

public String reverseOnlyLetters(String s) {
    int left = 0;
    int right = s.length()-1;
    char[] chars = s.toCharArray();
    while (left < right) {
        while (left < right&&!isEnglishChar(chars[left])){
            left++;
        }
        while (left < right&&!isEnglishChar(chars[right])){
            right--;
        }
        if (left < right){
            char c = chars[left];
            chars[left] = chars[right];
            chars[right] = c;
            left++;
            right--;
        }
    }
    return new String(chars);
}

public boolean isEnglishChar(char c){
    if((c>='a'&&c<='z')||(c>='A'&&c<='Z')){
        return true;
    }else {
        return false;
    }
}

反转字符串中的单词

leetcode151
首先对字符串进行反转，然后去掉字符串首尾多余空格，最后去掉单词之间的空格并反转单词

public String reverseWords(String s) {
    char[] chars = s.toCharArray();
    int len = s.length();
    reverse(chars, 0, len - 1);
    StringBuilder sb = new StringBuilder();
    int start = 0;
    while (start < len && chars[start] == ' ') {
        start++;
    }
    int end = len - 1;
    while (end > 0 && chars[end] == ' ') {
        end--;
    }
    int index = start;
    while (index <= end) {
        if (chars[index] != ' ') {
            sb.append(chars[index]);
        } else if (chars[index] == ' ' && chars[index - 1] != ' ') {
            sb.append(chars[index]);
        }
        index++;
    }
    s = sb.toString();
    chars = s.toCharArray();
    start = 0;
    index = 0;
    while (index < chars.length) {
    	if (chars[index] != ' ') {
            index++;
        } else {
            reverse(chars, start, index - 1);
            index++;
            start = index;
        }
    }
    reverse(chars,start,index-1);
    return new String(chars);
}

public void reverse(char[] chars, int left, int right) {
    while (left < right) {
        char c = chars[left];
        chars[left] = chars[right];
        chars[right] = c;
        left++;
        right--;
    }
}

判断回文串

leetcode125
首先将大写字符转换为小写字符，然后使用双指针进行判断

public boolean isPalindrome(String s) {
    StringBuilder sb = new StringBuilder();
    char[] chars = s.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        if (chars[i] >= 'A' && chars[i] <= 'Z') {
            chars[i] += 32;
            sb.append(chars[i]);
        } else if (chars[i] >= 'a' && chars[i] <= 'z') {
            sb.append(chars[i]);
        } else if (chars[i] >= '0' && chars[i] <= '9') {
            sb.append(chars[i]);
        }
    }
    s = sb.toString();
    chars = s.toCharArray();
    int left = 0;
    int right = chars.length - 1;
    while (left < right) {
        if (chars[left]!=chars[right]){
            return false;
        }
        left++;
        right--;
    }
    return true;
}

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

leetcode387
使用HashMap存储每个字符出现的次数，之后遍历字符数组，寻找第一个唯一字符

public int firstUniqChar(String s) {
    Map<Character,Integer> map = new HashMap<>();
    char[] chars = s.toCharArray();
    for (int i = 0; i < chars.length;i++){
        if (!map.containsKey(chars[i])){
            map.put(chars[i],1);
        }else {
            map.put(chars[i],map.get(chars[i])+1);
        }
    }
    for (int i = 0; i < chars.length;i++){
        if (map.get(chars[i])==1){
            return i;
        }
    }
    return -1;
}

判断两个字符串是否互为字符重排

leetcode242
设置一个长度为26的数组用来计数字符串中26个字符出现的次数，遍历第一个字符串时，对遍历到的每一字符对应的下标加一，遍历第二个字符串时，对遍历到的每一字符对应的下标减一，最后判断整个数组是否全为0

public boolean isAnagram(String s, String t) {
    if(s.length()!=t.length()){
        return false;
    }
    int[] res = new int[26];
    char[] chars = s.toCharArray();
    for (char c : chars){
        res[c-'a']++;
    }
    chars = t.toCharArray();
    for (char c : chars){
        res[c-'a']--;
    }
    for (int i=0;i<res.length;i++){
        if(res[i]!=0){
            return false;
        }
    }
    return true;
}

最长公共前缀

leetcode14
直观上来看，有竖直和水平两种方式，竖直方式是指我们依次比较所有字符串的第一个字符，如果相同，继续比较所有字符串的下一个字符，直至不相同或者有一个字符串遍历结束。水平方式是指可以先比较前两个字符的最长公共前缀，然后在比较前两个字符的最长公共前缀，与第三个字符的公共前缀，以此类推。同时，采用水平方式时，我们可以使用归并的方式，两两一组找最长公共前缀，然后再进行归并。

public String longestCommonPrefix(String[] strs) {
    StringBuilder sb = new StringBuilder();
    int len = strs.length;
    int n = strs[0].length();
    for (int i = 0; i < n; i++) {
        char c = strs[0].charAt(i);
        for (int j = 1; j < len; j++) {
            if (i >= strs[j].length() || strs[j].charAt(i) != c){
                return sb.toString();
            }
        }
        sb.append(c);
    }
    return sb.toString();
}

public String longestCommonPrefix(String[] strs) {
     int len = strs.length;
     if (len == 1) {
         return strs[0];
     }
     String prefix = longestCommonPrefix(strs[0], strs[1]);
     for (int i = 2; i < len; i++) {
         prefix = longestCommonPrefix(prefix, strs[i]);
     }
     return prefix;
 }

 public String longestCommonPrefix(String str1, String str2) {
     StringBuilder sb = new StringBuilder();
     int i = 0;
     int j = 0;
     while (i < str1.length() && j < str2.length()) {
         if(str1.charAt(i) == str2.charAt(j)){
             sb.append(str1.charAt(i));
             i++;
             j++;
         }else {
             return sb.toString();
         }
     }
     return sb.toString();
 }

压缩字符串

leetcode443
可以设置两个指针，用于寻找重复字符的起始和结束位置，同时在设置一个指针，用于设置写入位置，遍历字符数组，但个字符直接追加，重复字符，写入当前字符和出现次数，对于两位以上的出现次数，可以先逆序写入，然后再反转

public int compress(char[] chars) {
    int left = 0;
    int right = 0;
    int write = 0;
    while (right < chars.length) {
        while (right < chars.length && chars[right] == chars[left]) {
            right++;
        }
        if (right - left == 1) {
            chars[write++] = chars[left];
            left = right;
        } else {
            int count = right - left;
            chars[write++] = chars[left];
            int start = write;
            while (count != 0) {
                int num = count % 10;
                chars[write++] = (char) ('0' + num);
                count/=10;
            }
            reverse(chars, start, write - 1);
            left = right;
        }
    }
    return write;
}

public void reverse(char[] chars, int left, int right) {
    while (left < right) {
        char temp = chars[left];
        chars[left] = chars[right];
        chars[right] = temp;
        left++;
        right--;
    }
}
今天不coding
关注
  • 15
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言试题167之字符串加密和解密算法
码莎拉蒂
06-07 1783
题目：在本实例中要求设计一个加密和解密算法。在对一个指定的字符串加密之后，利用解密函数能够对密文解密，显示明文信息。加密的方式是将字符串中每个字符加上它在字符串中的位置和一个偏移值 5。以字符串“mrsoft”为例，第一个字符“m”在字符串中的位置为 0，那么它对应的密文是“‘m’+0+5"，即 r。分析： 在 main() 函数中使用 while 语句设计一个无限循环，并定义两个字符数组，用来保存，明文和密文字符串，在首次循环中要求用户输入字符串，进行将明文加密成密文的操作， 之后的操作则是根据用户输入的
LeetCode 5302. 加密解密字符串
英雄哪里出来
04-03 1670
字典树
算法分析-面试1-字符串
sutingStart的博客
02-24 989
算法：一个刷一段时间很有感觉，然后一段时间内不刷又忘了的一种面试工具。但是重点还得理解其思想。其实还是对字符串的增删改查遍历（正序、倒序、修改后或者替换后再遍历），总的来讲这是最简单的，主要是得明确哪些API的作用是什么，以及正则表达式怎么用。
【编程之路】面试必刷TOP101：字符串（83-86，Python实现）
书山有路，学海无涯。记录成长，追逐梦想
08-14 449
面试必刷TOP101：字符串（83-86，Python实现）
算法必刷系列之贪心
今天不coding的博客
12-01 1078
贪心算法不一定能求得最优解，使用贪心的场景要求问题具有最优子结构。其实是比较抽象的。贪心算法的常见体现主要在图相关算法，堆排序等复杂算法，不再刷题的范围之内，我们做要掌握的贪心题目主要有区间问题和跳跃游戏问题。并通过刷题培养对贪心题目的感觉
《算法系列》之模拟
小夏陌的博客
08-13 1360
模拟题大多给人的感觉是，脑子会了，手就是调不出来，会对代码的掌握能力要求很高。
KMP算法略讲与字符串总结
wyr1849089774的博客
01-19 137
KMP算法难度较大，在理解时会有很大的难度，在这里建议大家参考LeetCode28. 实现 strStr()、LeetCode459.重复的子字符串两个题目，并参照代码随想录进一步理解。
LeetCode 6036. 构造字符串的总得分和
英雄哪里出来
04-03 1079
字符串哈希
《算法系列》之双指针
小夏陌的博客
07-23 6255
双指针并不是一种数据结构，也不是指C这种语言中的指针，而是一种经典的算法思想。
为了OFFER | 腾讯2020校招后端《解压字符串》
微信号：RunsenLiu
09-06 1331
大四刷题拼offer系列，不拼不行啊。自己知道自己的数据结构算法很菜。而且2020/9/6今晚还有腾讯的笔试，祝我好运吧。自己知道成功的可能性很低，但还是刷下腾讯的算法题。
51单片机串口收发字符串+rc522刷卡
01-08
程序中会包含串口接收中断服务程序，用于读取并存储接收到的字符串。 **RC522 RFID模块** RC522是NXP公司生产的非接触式RFID读写模块，基于MFRC522芯片，主要工作在13.56MHz的频段。它支持ISO/IEC 14443A标准的...
算法问题：刷过的题
02-12
7. **字符串处理**：如KMP算法、Trie树等，用于高效地处理文本信息。 8. **数据结构**：链表、栈、队列、堆、哈希表、树（二叉树、平衡树如AVL和红黑树）等，它们是实现算法的基础。 通过刷题，不仅可以提升算法...
cpp代码-Leecode必刷题
07-14
对于LeetCode的题目，通常分为几个类别：数组、链表、字符串、二叉树、图、回溯、动态规划、位操作等。每个类别都涵盖了一系列的算法，如排序、查找、哈希、分治、贪心、递归等。通过实践，开发者不仅可以掌握各种...
算法面试专题课(Java版)，Google面试官带你高质量刷题视频教程
08-11
6. **字符串处理**：探讨字符串匹配算法，如KMP、Rabin-Karp和Boyer-Moore，以及如何进行字符串操作和模式匹配。 7. **位运算**：讲解位运算在优化算法中的应用，例如用位运算实现快速的乘除、取模、查找等操作。 ...
CSP 2020 第三题：表达式
m0_46183615的博客
08-03 508
CSP 2020 第三题：表达式
5力扣：最长回文子串
m0_75015083的博客
08-02 368
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
VRF 算法流程及代码实现
smilejiasmile的博客
08-03 205
Verifiable Random Functions (VRFs) 是一种密码学原语，能够为给定输入生成一个随机输出，并提供一个可以验证的证明，证明输出是由特定输入生成的。VRFs 具有许多应用，包括区块链、分布式系统和安全协议。使用secp256k1曲线可以产生确定性签名，适用于 VRF 实现。通过使用 HMAC-SHA256 生成确定性随机数k，可以确保签名过程对相同的输入始终产生相同的结果，从而满足 VRF 的要求。
【算法】动态规划解决背包问题
最新发布
2302_78914800的博客
08-04 417
1.动态规划算法的核心是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法2.动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解3.与分治算法不同的是，适合于用动态规划求解的问题，经分解得到的子问题往往不是相互独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）4.动态规划可以通过填表的方式来逐步推进，得到最优解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今天不coding

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值