LeetCode相关典型题解合集——字符串

所有的题型目录在下面的链接
LeetCode相关典型题解合集（两百多道题）

---

一、242. Valid Anagram

思路一：对两个字符串进行排序，然后比较
思路二：哈希表。然后s中的出现的计数，然后遍历t中的，减去，如果最后结果不为0，这说明不一样

bool isAnagram(string s, string t) {
        //字母序，一次比较
        if(s.length()!=t.length()){
            return false;
        }
        sort(s.begin(),s.end());
        sort(t.begin(),t.end());
        return s==t;
    }

bool isAnagram(string s, string t) {
        //哈希表
        if(s.length()!=t.length()){
            return false;
        }
        unordered_map<char,int> res;
        for(int i=0;i<s.length();i++){
            res[s[i]]++;
        }
        for(int i=0;i<t.length();i++){
            res[t[i]]--;
        }
        //判断是否有不为0的，若有肯定返回false
        for(int i=0;i<t.length();i++){
            if( res[t[i]]!=0){
                return false;
            }
        }
        return true;
    }

二、409. Longest Palindrome

思路： 哈希表，大于2的奇数。注意一种情况：“dd”

int longestPalindrome(string s) {
        unordered_map<char,int> res;
        if(s.length()==1){
            return 1;
        }
        for(int i=0;i<s.length();i++){
            res[s[i]]++;
        }
        int count=0;
        for(int i=0;i<s.length();i++){
            if(res[s[i]]>=2){
                count+=res[s[i]]/2;
                res[s[i]]=0;
            }
        }
        return (2*count+1)>s.length()?2*count:2*count+1;
    }

三、205.Isomorphic Strings

我们可以利用一个哈希表来处理映射。对于 s 到 t 的映射，我们同时遍历 s 和 t ，假设当前遇到的字母分别是 c1 和 c2 。
如果 map[c1] 不存在，那么就将 c1 映射到 c2 ，即 map[c1] = c2。
如果 map[c1] 存在，那么就判断 map[c1] 是否等于 c2，也就是验证之前的映射和当前的字母是否相同。

注意！需要验证两次，来回的！

bool isIsomorphic(string s, string t) {
         return doubleVerify(s,t)&&doubleVerify(t,s);
    }
    //验证两次！就是有可能出现“ab”和“aa”这种情况
    bool doubleVerify(string s, string t){
        unordered_map<char,char> res;
        for(int i=0;i<s.length();i++){
            if(res.count(s[i])==1){
                if(res[s[i]]!=t[i]){
                    return false;
                }
            }else{
                res[s[i]]=t[i];
            }   
        }
        return true;
    }

四、647. Palindromic Substrings

思路一：中心扩展法
思路二：动态规划

中心扩展法

 int countSubstrings(string s) {
        int count=0;
        for(int i=0;i<2*s.length()-1;i++){
            int left=i/2;
            int right=left+i%2;
            while(left>=0&&right<s.length()&&s[left]==s[right]){
                count++;
                left--;
                right++;
            }
        }
        return count;
    }

五、9. Palindrome Number

1、负数一定不是
2、大于0小于10的一定是
3、取余为0的一定不是
4、用哈希

 bool isPalindrome(int x) {
        if(x<0){
            return false;
        }
        if(x>0&&x<10){
            return true;
        }
        if(x>0&&x%10==0){
            return false;
        }
        unordered_map<int,int> rev;
        int count=0;
        int temp=x;
        while(temp>0){
            int value=temp%10;
            rev[count++]=value;
            temp=temp/10;
        }
        int i=0;
        int num=count-1;
        while(num>=0){
            if(rev[i++]!=rev[num--]){
                return false;
            }
        }
        return true;
    }

六、696. Count Binary Substrings

这道题目的重点是：子串，0或者1连续，0的数量=1的数量，每个字符可以被重复的计算
只要知道上述几个特点就可以很轻松的做出来
思路：把0和1的数量用数组表示，比如0001110={3,3,1}

int countBinarySubstrings(string s) {
        vector<int> arr;
        //这里最好用while来写
        int num=0;
        while(num<s.length()){
            int count=0;
            char str=s[num];
            while(str==s[num]&&num<s.length()){
                count++;
                num++;
            }
            arr.push_back(count);
        }
        int sum=0;
        for(int i=1;i<arr.size();i++){
            sum+=arr[i-1]<arr[i]?arr[i-1]:arr[i];
        }
        return sum;
    }