【LeetCode之字符串】

---

前言

题目来源

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、两个字符串包含的字符是否完全相同

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

class Solution {
    public boolean isAnagram(String s, String t) {
    int[] cnts = new int[26];
    for (char c : s.toCharArray()) {
        cnts[c - 'a']++;
    }
    for (char c : t.toCharArray()) {
        cnts[c - 'a']--;
    }
    for (int cnt : cnts) {
        if (cnt != 0) {
            return false;
        }
    }
    return true;
   }
}

二、计算一组字符集合可以组成的回文字符串的最大长度

给定一个包含大写字母和小写字母的字符串 s ，返回 通过这些字母构造成的 最长的回文串 。

class Solution {
    public int longestPalindrome(String s) {
        HashMap<Character,Integer> hashMap=new HashMap<>();
        int len=s.length();
        for(int i=0;i<len;++i){
            char c=s.charAt(i);
            hashMap.put(c,hashMap.getOrDefault(c,0)+1);
        }
        Iterator iterator=hashMap.values().iterator();
        int num=0;
        while (iterator.hasNext()){
            int time=(int)iterator.next();
            num+=(time/2)*2;    //如果是双的就加的是个数，如果是单的加的就是单的-1
        }
        if(num<len)
            num++;   //注意如果有个单的就可以放中间哈哈哈
        return num;
    }
}

三、字符串同构

给定两个字符串 s 和 t ，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int[] preIndexOfS = new int[256];
        int[] preIndexOfT = new int[256];
        for (int i = 0; i < s.length(); i++) {
            char sc = s.charAt(i), tc = t.charAt(i);
            if (preIndexOfS[sc] != preIndexOfT[tc]) {   //其实只有一个的时候肯定没问题，就是连续两个或三个的时候才会出问题
                return false;
            }
            preIndexOfS[sc] = i + 1;
            preIndexOfT[tc] = i + 1;
        }
        return true;
    }
}

四、回文子字符串个数

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。
回文字符串 是正着读和倒过来读一样的字符串。
子字符串 是字符串中的由连续字符组成的一个序列。
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

这个题两个思路，第一种是判断所有的子字符串并判断是否为回文子串；第二种是使用动态规划的思想；
方法一：

//所有子字符串的“中心”可能是第i个字符；也可能是第i+（i+1）个字符；
class Solution {
    int ans=0;
    public int countSubstrings(String s) {
        int len=s.length();
        for(int i=0;i<len;++i){
            extendsub(s,i,i);
            extendsub(s,i,i+1);
        }
        return ans;
    }
    public void extendsub(String  s,int left,int right){
        int len=s.length();
        while (left>=0 && right<len){
            if(s.charAt(left)!=s.charAt(right))
                return;
            ++ans;
            --left;
            ++right;
        }
    }
}

方法二：

class Solution {
    public int countSubstrings(String s) {
        int ans = 0;
        boolean[][] dp =  new boolean[s.length()][s.length()];
        int len=s.length();
        for(int i=len-1;i>=0;--i)    //注意i是从下到上；
            for(int j=i;j<len;++j){   //j是从i到len-1；
                if(s.charAt(i) == s.charAt(j)){
                    if(j - i <= 1){
                        dp[i][j] = true;
                        ans++;
                    }else if(dp[i + 1][j - 1]){
                        dp[i][j] = true;
                        ans++;
                    }
                }
            }
        return ans;
    }
}

五、判断一个整数是否是回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

class Solution {
    public boolean isPalindrome(int x) {
        if(x==0) return true;    //则为0
        if (x < 0 || x % 10 == 0) return false;   //1-9返回false
        int pre=x,end=0;
        while (pre>end){
            end=end*10+pre%10;
            pre/=10;
        }
        if(pre==end || pre==end/10) return true;  //这两种情况
        return false;
    }
}

六、统计二进制字符串中连续1和连续0数量相同的子字符串个数

给定一个字符串 s，统计并返回具有相同数量 0 和 1 的非空（连续）子字符串的数量，并且这些子字符串中的所有 0 和所有 1 都是成组连续的。

两种方法，原理是一样的，获取相邻0和1中相对小的那个，比如000111，它有相同0和1个数的子字符串有3个，分别是：000111和0011和01。

class Solution {
    public int countBinarySubstrings(String s) {
        List<Integer> counts = new ArrayList<Integer>();
        int ptr = 0, n = s.length();
        while (ptr < n) {
            char c = s.charAt(ptr);
            int count = 0;
            while (ptr < n && s.charAt(ptr) == c) {
                ++ptr;
                ++count;
            }
            counts.add(count);
        }
        int ans = 0;
        for (int i = 1; i < counts.size(); ++i) {
            ans += Math.min(counts.get(i), counts.get(i - 1));
        }
        return ans;
    }
}

class Solution {
    public int countBinarySubstrings(String s) {
        int preLen = 0, curLen = 1, count = 0;
        for (int i = 1; i < s.length(); i++) {
            if (s.charAt(i) == s.charAt(i - 1)) {
                curLen++;
            } else {
                preLen = curLen;
                curLen = 1;
            }
            if (preLen >= curLen) {  //注意这里哈
                count++;
            }
        }
        return count;
    }
}

---