leetcode_字符串

字符串循环移位包含

编程之美 3.1

s1 = AABCD, s2 = CDAA
Return : true

题解： 给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。

字符串循环移位

编程之美 2.17

s = "abcd123" k = 3
Return "123abcd"

题解：
将字符串向右循环移动 k 位。
将 abcd123 中的 abcd 和 123 单独翻转，得到 dcba321，然后对整个字符串进行翻转，得到 123abcd。

字符串中单词的翻转

程序员代码面试指南

s = "I am a student"
Return "student a am I"

题解：
将每个单词翻转，然后将整个字符串翻转。

---

242. 有效的字母异位词* (简单)

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true
示例 2:

输入: s = "rat", t = "car"
输出: false

说明:
你可以假设字符串只包含小写字母。
进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

题解：
1.转换为数组再排序
将两个字符串排序，字母异位词排序后一模一样。
首先判断长度是否相等，不相等直接返回false;

class Solution {
   public boolean isAnagram(String s, String t) {
    //长度不相等，立即返回false
    if (s.length() != t.length()) {
        return false;
    }
    //字符串转化为数组
    char[] str1 = s.toCharArray();
    char[] str2 = t.toCharArray();
    //数组排序
    Arrays.sort(str1);
    Arrays.sort(str2);
    //数组比较
    return Arrays.equals(str1, str2);
    }
}

时间复杂度O(nlogn)
空间复杂度O(1): 空间取决于排序实现，如果使用 heapsort，通常需要O(1) 辅助空间。注意，在 Java 中，toCharArray() 制作了一个字符串的拷贝，所以它花费 O(n) 额外的空间，但是我们忽略了这一复杂性分析，因为：这依赖于语言的细节。 这取决于函数的设计方式。例如，可以将函数参数类型更改为 char[]。

2. 桶计数

// 字母桶计数ver1:
// 若两个字符串长度不等，立即返回false
// 先对s中字符计数
// 对t中字符计数，t中相应字符计数减1，若某个字母计数小于0，立即返回false
class Solution {
    public boolean isAnagram(String s, String t) {
        int[] table = new int[26];
        if (s.length() != t.length()){
            return false;
        }
        //s中的字符计数
        for (int i= 0; i<s.length(); i++){
            table[s.charAt(i)-'a']++;   
        }
        
        //s计数基础上，t中相应字符计数减1
        for (int i = 0; i<t.length(); i++){
            table[t.charAt(i) - 'a']--;
            if (table[t.charAt(i) - 'a'] < 0)   //若某一个字符计数小于0时，立即返回false
                return false;
        }
        return true;
    }
}
// 字母桶计数ver2:
// 若两个字符串长度不等，立即返回false
// 先对s中字符计数
// 查看字母表是否每个字符计数为0，不是返回false
class Solution {
    public boolean isAnagram(String s, String t) {
        int[] table = new int[26];
        if (s.length() != t.length()){
            return false;
        }
        //s中的字符计数
        for (int i= 0; i<s.length(); i++){
            table[s.charAt(i)-'a']++;   
            table[t.charAt(i)-'a']--;
        }
        
        //s计数基础上，t中相应字符计数减1
        for (int i = 0; i<26; i++){
            if (table[i]!=0)
                return false;
        }
        return true;
    }
}

时间复杂度O(n)
空间复杂度O(1)

---

409. 最长回文串

给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。
在构造过程中，请注意区分大小写。比如 “Aa” 不能当做一个回文字符串。
注意:
假设字符串的长度不会超过 1010。

示例 1:

输入:
"abccccdd"
输出:
7

解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。

题解：
对于回文字符串，最多只有一个字符的个数是1个，其余字符必为偶数个
用一个桶统计每个出现的字符的个数。
某字母个数为偶数个，加上该字母个数
某字母个数为奇数个，加上该字母的个数再减1
若结果长度小于原字符串长度：结果长度再加1

class Solution {
    public int longestPalindrome(String s) {
        int res = 0;
        //大写和小写字母之间有6个其他字符，因此数组大小：52+6
        int[] bucket = new int[58];
        
        for (int i = 0; i<s.length(); i++){
            bucket[s.charAt(i) - 'A'] ++; 
        }
        int flag = 0;
        for (int x: bucket){
            res += x - (x & 1);  //取x的最大偶数个，若x为奇数，则减1
        }
        //若结果长度比s长度小，再加上一个字母的长度
        return res<s.length()? res+1: res;
    }
}

时间复杂度O(n)
空间复杂度O(1)

---

205. 同构字符串

给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 1:

输入: s = "egg", t = "add"
输出: true

示例 2:

输入: s = "foo", t = "bar"
输出: false

示例 3:

输入: s = "paper", t = "title"
输出: true

说明:
你可以假设 s 和 t 具有相同的长度。

题解：
1. 两个哈希表
根据题意，s唯一地映射到t， 且t唯一地映射到s.

如 s = "foo", t = "bar" 不同构
o -> a
o -> r
o 映射到了两个字母

如s = "ab", t = "cc"不同构
a -> c
b -> c
c 被映射了两次
反过来由 t 映射到 s
c -> a 
c -> b
c 映射到了两个字母

因此需要验证 s->t 成立，且 t->s 成立

class Solution {
    public boolean isIsomorphic(String s, String t) {
        Map<Character, Character> map1 = new HashMap<>();  //s->t
        Map<Character, Character> map2 = new HashMap<>();  //t->s
        
        for (int i = 0; i < s.length(); i++){
            //map1中不包含s[i]的映射, map2也不包含t[i]的映射，则将s[i]<->t[i] 加入映射表中
            if (!map1.containsKey(s.charAt(i)) && !map2.containsKey(t.charAt(i))){  
                map1.put(s.charAt(i), t.charAt(i));
                map2.put(t.charAt(i), s.charAt(i));
            }
            else{
                //若map1中存在s[i]的映射，但s[i]-/>t[i], 返回false
                if (map1.containsKey(s.charAt(i)) && map1.get(s.charAt(i)) != t.charAt(i))
                    return false;
                //若map1中存在t[i]的映射，但t[i]-/>t[i], 返回false
                else if (map2.containsKey(t.charAt(i)) && map2.get(t.charAt(i))!= s.charAt(i))
                    return false;
            } 
        }
        return true;
    }
}

时间复杂度O(n)
空间复杂度O(n)

2. 一个哈希表
s -> t 与 t -> s 两个方向分次进行

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

时间复杂度O(n)
空间复杂度O(n)

647. 回文子串*？

---

9. 回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true

示例 2:

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

示例 3:

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

进阶:
你能不将整数转为字符串来解决这个问题吗？

题解：
1. 数字转化为字符串

2. 将整个数字翻转
回文数翻转后和原来的数相等。
翻转的方式：

revertedNum = revertedNum*10 + temp%10;
temp = temp/10;

```java
class Solution {
    public boolean isPalindrome(int x) {
        if (x<0 || ( x%10 == 0 && x!=0)){  //注意边界条件
            return false;
        }
        int temp = x;
        int revertedNum = 0;
        while (temp > 0){
            revertedNum = revertedNum*10 + temp%10;
            temp = temp/10;
        }
        return x == revertedNum;
    }
}

时间复杂度O(log10(n))
空间复杂度O(1)

**3. 翻转一半的数**
翻转了一半时： x < revertedNum
同时注意，当原数有奇数位数时，翻转后的数会多一位，只要再除以10然后比较即可。
最后注意边界条件。
- 当x为负数时，不是回文数
- 当x非0，但最后一位为0时，不是回文数

```java
class Solution {
    public boolean isPalindrome(int x) {
        if (x<0 || ( x%10 == 0 && x!=0)){  //注意边界条件
            return false;
        }
        
        int revertedNum = 0;
        while (x > revertedNum){
            revertedNum = revertedNum*10 + x%10;
            x = x/10;
        }
        return x == revertedNum || x == revertedNum/10;
    }
}

时间复杂度O(log10(n))
空间复杂度O(1)

---

696. 计数二进制子串

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

示例 1 :

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

请注意，一些重复出现的子串要计算它们出现的次数。
另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。

示例 2 :

输入: "10101"
输出: 4
解释: 有4个子串：“10”，“01”，“10”，“01”，它们具有相同数量的连续1和0。

注意：
s.length 在1到50,000之间。
s 只包含“0”或“1”字符。

题解：
1. 按字符分组
将字符串 s 转换为 arr 数组表示字符串中相同字符连续块的长度。例如，如果 s=“11000111000000”，则 arr=[2，3，3，6]。

• '0' * k + '1' * k 或 '1' * k + '0' * k 形式的每个二进制字符串，有k个子串。
• 对于相邻的两个字符块，arr[i-1] 和arr[i]的子串个数为min(arr[i-1], arr[i])

//按字符分组
class Solution {
    public int countBinarySubstrings(String s) {
        int res = 0;
        int n = s.length();
        if (n == 0 || n == 1){
            return res;
        }
        
        //按字符分组，存放到arr中
        int[] arr = new int[n];
        arr[0] = 1;
        int index = 0;
        for (int i = 1; i < s.length(); i++){
            if (s.charAt(i) == s.charAt(i-1)){
                arr[index]++; 
            }else{
                arr[++index] = 1;
            }
        }
        //计算每个相邻字符块的字串个数
        for (int i = 1; i<n; i++){
            res += Math.min(arr[i], arr[i-1]);
        }
        return res;
    }
}

时间复杂度O(n)
空间复杂度O(n)

2. 线性扫描
时时记录结果

class Solution {
     public int countBinarySubstrings(String s) {
        int n = 0, pre = 0, curr = 1, len = s.length()-1;
        for (int i = 0; i < len; ++i) {
            if (s.charAt(i) == s.charAt(i+1)) 
                curr++;
            else{
                pre = curr; 
                curr = 1;
            }               
            if (pre >= curr)
                ++n;
        }
       return n;
    }
}

时间复杂度O(n)
空间复杂度O(1)