【题解】《算法零基础100讲》(第24讲) 字符串算法(四) - 字符计数法（java版）

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

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

今日题解：
第一题：https://leetcode-cn.com/problems/is-unique-lcci/

我们使用嵌套循环，先把字符串转换为数组，然后遍历即可。

class Solution {
    public boolean isUnique(String astr) {
        char[] c = astr.toCharArray();
        int i,j;
        for(i = 0; i < c.length; i++){
            for(j = i + 1 ; j < c.length; j++){
                if(c[i] == c[j]){
                    return false;
                }
            }
        }
        return true;
    }
}

第二题：https://leetcode-cn.com/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof/

我们先遍历一遍数组，把出现的字母存到数组里面，然后再进行一次遍历，如果出现了出现次数是1的字母就返回。

class Solution {
    public char firstUniqChar(String s) {
        int l = s.length();
        int[] array = new int[80];
        int i,j;
        char c;
        for (i = 0; i < l; i++){
            c = s.charAt(i);
            array[c - 'a']++;
        }
        for (i = 0; i < l; i++){
            c = s.charAt(i);
            if (array[c - 'a'] == 1){
                return c;
            }
        }
        return ' ';
    }
}

第三题：https://leetcode-cn.com/problems/ransom-note/

我们先遍历一遍数组，遇到了就统计出现的次数，然后再进行一次循环遍历，如果他的次数是0，就代表还没有出现过，直接返回false，否则我们进行一次次数的抵消。

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        char[] count = new char[80];
        int  i;
        for (i = 0; i < magazine.length(); i++) {
            count[magazine.charAt(i) - 'a']++;
        }
        for (i = 0; i < ransomNote.length(); i++) {
            if (count[ransomNote.charAt(i) - 'a'] == 0) {
                return false;
            }else{
                count[ransomNote.charAt(i)- 'a']--;
            }
        }
        return true;
    }
}

第四题：https://leetcode-cn.com/problems/jewels-and-stones/

比较简单，直接遍历即可。

class Solution {
    public int numJewelsInStones(String jewels, String stones) {
        char[] c1 = jewels.toCharArray();
        char[] c2 = stones.toCharArray();
        int i,j,count=0;
        for(i = 0; i < c1.length; i++){
            for(j = 0; j < c2.length; j++){
                if(c1[i] == c2[j]){
                    count++;
                }
            }
        }
        return count;
    }
}

第五题：https://leetcode-cn.com/problems/check-permutation-lcci/

先排序，然后比较两个数组是否相等，相等即满足题目的要求。

class Solution {
    public boolean CheckPermutation(String s1, String s2) {
        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();
        Arrays.sort(c1);
        Arrays.sort(c2);
        if(Arrays.equals(c1, c2)){
            return true;
        }else{
            return false;
        }
    }
}

第六题：https://leetcode-cn.com/problems/check-if-all-characters-have-equal-number-of-occurrences/

class Solution {
    public boolean areOccurrencesEqual(String s) {
        int[] array=new int[26];
        int i,j;
        for(i=0; i<s.length(); i++){
            array[s.charAt(i)-'a']++;
        }
        for(i=0; i<26; i++){
            if(array[s.charAt(0)-'a']!=array[i] && array[i]!=0){
/*我每一个字符出现的次数一样，我才可以算作是好字符串，
所以array[s.charAt(0)-'a']!=array[i]就代表有一个字符的次数与其他的不一样，
并且array[i]!=0，也就是这个字符确实存在于你的输入里面，那么此时不符合题意。*/
                return false;
                }
            }
        return true;
    }
}

第七题：https://leetcode-cn.com/problems/valid-anagram/

先排序，然后比较是否相等，思路也很简单。

class Solution {
    public boolean isAnagram(String s, String t) {
        char[] c1 = s.toCharArray();
        char[] c2 = t.toCharArray();
        Arrays.sort(c1);
        Arrays.sort(c2);
        if(Arrays.equals(c1, c2)){
            return true;
        }else{
            return false;
        }
    }
}

第八题：https://leetcode-cn.com/problems/dKk3P7/

思路也可以将上一道题的思路反过来，我们先判断是否是不完全相同，然后再判断里面所含的字母是否完全相同。

class Solution {
    public boolean isAnagram(String s, String t) {
        char[] c1 = s.toCharArray();
        char[] c2 = t.toCharArray();
        int i,j,flag=1;
        for(i = 0; i < c1.length; i++){
            for(j = 0; j < c2.length; j++){
                if(c1[i] != c2[j]){
                    flag = 1;
                    break;
                }else{
                    flag = 0;
                }
            }
        }
        if(flag == 1){
            Arrays.sort(c1);
            Arrays.sort(c2);
            if(Arrays.equals(c1, c2)){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }
}

第九题：https://leetcode-cn.com/problems/check-if-the-sentence-is-pangram/

先定义一个数组，我们先把字母表存进去，然后我们遍历我们的字符串，如果包含，我们就定义一个变量，并且跳出判断，只有当判断到最后一个字母并且变量值符合条件，我们才会返回true，否则返回false。

class Solution {
    public boolean checkIfPangram(String sentence) {
         char[] Zimu = new char[]{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
         int i,j;
         char[] c = sentence.toCharArray();
         for(i = 0; i < 26; i++) {
            int flag = 0;
            for(j = 0; j < sentence.length(); j++) {
                if(Zimu[i] == sentence.charAt(j)){
                    flag = 1;
                    break;
                }
            }
            if(flag == 0){
                return false;
            }
            if(flag == 1){
                continue;
            }
            if(flag == 1 && i == 25){
                return true;
            }
        }
        return true;
    }
}

第十题：https://leetcode-cn.com/problems/kth-distinct-string-in-an-array/

第一次遍历，将arr数组中所有的字符串保存到哈希表中，其中哈希表的key保存字符串，value保存每个字符串出现次数。第二次遍历，将哈希表中只出现一次的字符串添加到ArrayList中。

class Solution {
    public String kthDistinct(String[] arr, int k) {
        Map<String, Integer> map = new HashMap<>();
        int i;
        for (i = 0; i < arr.length; i ++) {
            map.put(arr[i], map.getOrDefault(arr[i], 0) + 1);
        }
        List<String> list = new ArrayList<>();
        for (i = 0; i < arr.length; i ++) {
            if (map.get(arr[i]).equals(1)) {
            //如果arr[i]所对应的出现次数等于1，表示这个只出现过1次
                list.add(arr[i]);
            }
        }
        if(list.size() < k){
            return "";
        }else{//若k比list的长度还大，返回空，否则，返回list中第(k - 1)个元素
            return list.get(k - 1);
        }
    }
}

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