【题解】《算法零基础100讲》(第22讲) 字符串算法(二) - 字符串比较（java版）

😁算法小白欢迎加入此社区：https://bbs.csdn.net/forums/hero?category=0
由英雄大佬带领的抱团学算法队伍，从0开始，期待你的加入🥳

本博文是对此文章习题所作的题解，如有不足，请多指教：https://blog.csdn.net/WhereIsHeroFrom/article/details/120875787

今日题解：
第一题：https://leetcode-cn.com/problems/ti-huan-kong-ge-lcof/

第一看想到的就是调用java自带的方法。

class Solution {
    public String replaceSpace(String s) {
       return s.replace(" ","%20");
    }
}

也可以定义动态数组，使用StringBuilder来求解，这个我开始没想到，看的评论区的大佬想法。

class Solution {
    public String replaceSpace(String s) {
        StringBuilder arr = new StringBuilder();
        int i;
        for(i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if(c == ' '){
                arr.append("%20");
            }else{
                arr.append(c);
            }
        }
        return arr.toString();
    }
}

第二题：https://leetcode-cn.com/problems/sparse-array-search-lcci/

我的想法比较菜，开始想到的就是直接遍历，然后使用java方法来判断。

class Solution {
    public int findString(String[] words, String s){
        int i;
        for(i = 0; i < words.length; i++){
            if(words[i].equals(s)){
                return i;
            }
        }
        return -1;
    }
}

当然这个题最好的解法是使用二分法，只不过当前位置为" "，我们定义的mid要进行前移，再放一个二分的大佬解法。

class Solution {
    public int findString(String[] words, String s) {
        int l = 0, r = words.length - 1;
        while(r >= l){
            int mid = (l + r)/2;
            while(mid > l &&  words[mid].equals("")){
                mid--;
            }
            if(s.compareTo(words[mid]) == 0){
                return mid;
            }
            if(s.compareTo(words[mid]) < 0){
                r = mid - 1;
            }else{
                l = mid + 1;
            }
        }
        return -1;
    }
}

第三题：https://leetcode-cn.com/problems/word-pattern/

本题开始没想到解法，看了大佬的题解，这里就写一个大佬题解的注释了。

class Solution {
    public boolean wordPattern(String pattern, String str) {
        String[] words = str.split(" ");
        if (words.length != pattern.length()) {
        // 字符和单词是一一对映的，数量必须相等
            return false;
        }
        Map<Object, Integer> map = new HashMap<>();
        for (Integer i = 0; i < words.length; i++) {
        //如果键值不存在，插入成功，返回null；如果键值存在，返回之前对应的value。
            if (map.put(pattern.charAt(i), i) != map.put(words[i], i)) {
                return false;
            }
        }
        return true;
    }
}

第四题：https://leetcode-cn.com/problems/decrypt-string-from-alphabet-to-integer-mapping/

暴力枚举，直接写出所有的情况。这里先要写 10# 的情况，因为先写 1，可能会把 10# 误认为1。

class Solution {
    public String freqAlphabets(String s) {
        String n1 = s.replaceAll("10#","j");
        String n2 = n1.replaceAll("11#","k");
        String n3 = n2.replaceAll("12#","l");
        String n4 = n3.replaceAll("13#","m");
        String n5 = n4.replaceAll("14#","n");
        String n6 = n5.replaceAll("15#","o");
        String n7 = n6.replaceAll("16#","p");
        String n8 = n7.replaceAll("17#","q");
        String n9 = n8.replaceAll("18#","r");
        String n10 = n9.replaceAll("19#","s");
        String n11 = n10.replaceAll("20#","t");
        String n12 = n11.replaceAll("21#","u");
        String n13 = n12.replaceAll("22#","v");
        String n14 = n13.replaceAll("23#","w");
        String n15 = n14.replaceAll("24#","x");
        String n16 = n15.replaceAll("25#","y");
        String n17 = n16.replaceAll("26#","z");
        String n18 = n17.replaceAll("1","a");
        String n19 = n18.replaceAll("2","b");
        String n20 = n19.replaceAll("3","c");
        String n21 = n20.replaceAll("4","d");
        String n22 = n21.replaceAll("5","e");
        String n23 = n22.replaceAll("6","f");
        String n24 = n23.replaceAll("7","g");
        String n25 = n24.replaceAll("8","h");
        String n26 = n25.replaceAll("9","i");
        return n26;
    }
}

大佬使用的逆序遍历，实现起来也是比较简单的。

class Solution {
    public String freqAlphabets(String s) {
        StringBuilder sb = new StringBuilder();
        int i = s.length() - 1;
        while(i >= 0){
        //先倒过来找'#',碰到了就是二位数，否则是一位数
            if(s.charAt(i) == '#'){
                i = i - 2;
                int x = Integer.parseInt(s.substring(i, i + 2));
                sb.append((char)('a' + x - 1));
            }else{
                int x = s.charAt(i) - '0';
                sb.append((char)('a' + x - 1));
            }
            i--;
        }
        sb.reverse();
        return sb.toString();
    }
}

第五题：https://leetcode-cn.com/problems/number-of-strings-that-appear-as-substrings-in-word/

第一想法嵌套循环，先循环数组长度，然后再遍历字符串的位数，使用substring方法，然后再进行比较。

class Solution {
    public int numOfStrings(String[] patterns, String word) {
        int i,j,k,t;
        int count = 0;
        for(i = 0; i < patterns.length; i++){
            t = 0;
            for(j = 0; j < word.length(); j++){
                for(k = j; k <= word.length(); k++){
                    if(word.substring(j,k).equals(patterns[i])){
                        count ++;
                        t = 1; 
                        break;
                    }
                    if (t == 1){
                        break;
                    }
                }
            }
        }
        return count;
    }
}

大佬有更好的解法，调用java里的contains方法。

class Solution {
    public int numOfStrings(String[] patterns, String word) {
        int number = 0;
        for(String s:patterns){
            if(word.contains(s)){
                number++;
            }
        }
        return number;
    }
}

有问题欢迎留言，欢迎加入“万人千题”社区，在这里一起努力。

近几天所欠的题解会尽快补上。