数据结构——leetcode（字符串）【java】

leetcode-242-有效字母异位词

力扣-242
题目：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词
示例：

输入: s = “anagram”, t = “nagaram”
输出: true
输入: s = “rat”, t = “car”
输出: false

思路：可以用hashmap存储，由于是字符串，只有26位，可以用数组来储存。

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

leetcode-409-最长回文串

力扣-409
题目：给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。

在构造过程中，请注意区分大小写。比如 “Aa” 不能当做一个回文字符串。
示例：

输入:
“abccccdd”
输出:
7
解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。

思路：回文字符串要求字符为偶数可以直接用，奇数剪一次再拿， c / 2 * 2 ，然后就是出现一次的只能算作一次，因为只能放在中间回文

 public int longestPalindrome(String s) {
        int[] count = new int[256];
        for (char c : s.toCharArray()) {
        count[c]++;
        }
        int palindrome = 0;
        for(int c:count){
            palindrome += (c/2)*2;
        }
        if(palindrome<s.length()){
            palindrome++;// 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
        }
        return palindrome;
    }

leetcode-205-同构字符串

力扣-205
题目：
给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。
示例：
输入: s = “egg”, t = “add”
输出: true

输入: s = “foo”, t = “bar”
输出: false

输入: s = “paper”, t = “title”
输出: true

思路：hashmap记录出现位置，int[]数组存储

public boolean isIsomorphic(String s, String t) {
        if(s.length()!=t.length()) return false;
        HashMap<Character,Character> map = new HashMap<>();
        for(int i=0;i<s.length();i++){
            if(!map.containsKey(s.charAt(i))){
                if(map.containsValue(t.charAt(i))){
                    return false;
                }
                map.put(s.charAt(i),t.charAt(i));
            }else{
                if(map.get(s.charAt(i))!=t.charAt(i)){
                    return false;
                }
            }
        }
        return true;
    }

public boolean isIsomorphic(String s, String t) {
        if(s.length()!=t.length()) return false;
        int [] ss = new int[256];
        int [] tt = new int[256];
        for(int i=0;i<s.length();i++){
            char sc = s.charAt(i);
            char tc = t.charAt(i);
            if(ss[sc]!=tt[tc]){
                return false;
            }
            ss[sc]=i+1;
            tt[tc]=i+1;
        }
        return true;

    }

leetcode-647-回文字符串

力扣-647
题目：给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。
示例：

输入: “abc”
输出: 3
解释: 三个回文子串: “a”, “b”, “c”.

输入: “aaa”
输出: 6
说明: 6个回文子串: “a”, “a”, “a”, “aa”, “aa”, “aaa”.

思路：中心扩展法，找到字符串中心点，确定了一个中心点后寻找路径，然后我们只要寻找到所有的中心点
解法确定中心点

public int countSubstrings(String s) {
        int ans = 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.charAt(left) == s.charAt(right)) {
                ans++;
                left--;
                right++;
            }
        }
        return ans;
    }

leetcode-9-判断一个数是否是回文数

力扣-9
题目：判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例：

输入: 121
输出: true

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数

思路：回文数三种思路 回文数的三种解法 | 法解种三的数文回：画动
1.转换成字符串
2.将数字% / 比较各位的值是否相同
3.将数字后半部分反转然后比较

 public boolean isPalindrome(int x) {
 	//1.
		String reversedStr =(new StringBuilder(x+"")).reverse().toString();
        return (x + "").equals(reversedStr);
	//3.
        if(x==0){ return true;}
        if(x<=0||x%10==0) return false;
        int revernum = 0;
        //将数字后半部分反转
        while(x>revernum){
            revernum = revernum*10+x%10;
            x/=10;
        }
        return x==revernum||x==revernum/10;
    }

leetcode-696-计数二进制数

力扣-696
题目：给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。
重复出现的子串要计算它们出现的次数。

示例：
输入: “00110011”
输出: 6
解释: 有6个子串具有相同数量的连续1和0：“0011”，“01”，“1100”，“10”，“0011” 和 “01”。

请注意，一些重复出现的子串要计算它们出现的次数。

另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。

思路：
给定的原字符串s只由0,1构成，可以将其看成多组连续的0与多组连续的1组成的。而且0与1的组是交替出现。
假设有4个1与3个0相连，”1111000“ 可以构成的子串有111000，1100，10，共3个；假设有3个0与2个1相连”00011“，可以构成的子串有0011，01，共两个。可以发现我们只要知道相连的两个分组的长度，就可以直接得到这两个组可以构成几个符合题意的子串，就是两分组的中较短的长度。

 public int countBinarySubstrings(String s) {
        int result = 0;
        char[]chars = s.toCharArray();
        int precount = 0;
        int curcount = 1;
        for(int i=1;i<chars.length;i++){
            if(chars[i-1]==chars[i]){
            // 记录当前组的数量
                curcount++;
            }
            else{
  //将连续的0,1分组后，相邻两组能满足题意的字符串              result+=Math.min(precount,curcount);
                precount = curcount;
                curcount=1;
            }
        }
        //循环结束后还有最后一组要和前一组进行计数
        return result+Math.min(precount,curcount);
    }