leetcode总结——字符串篇

字符串处理：
翻转字符串
同构字符串
异位字符串：

移位异构字符串
字符串的字典距离

无公共字母的字符串乘积

翻转字符串
给定一个字符串，逐个翻转字符串中的每个单词。
示例 1：

输入: “the sky is blue”
输出: “blue is sky the”
示例 2：

输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：

输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

import java.lang.*;
import java.util.*;
class Solution {
    public String reverseWords(String s) {
        StringBuilder builder=new StringBuilder();
        s=s.trim();//删除前后的空格
        int j=s.length(),i=s.length()-1;
        while(i>=0){
            if(s.charAt(i)==' '){
                builder.append(s.substring(i+1,j));
                builder.append(' '); 
                while (s.charAt(i) == ' ') i--; //删除中间连续的空格
                j=i+1;
            }
            i--;
        }
        builder.append(s.substring(i+1,j));
        return builder.toString();
    }            
}

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

示例 1:
输入: s = “egg”, t = “add”
输出: true

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

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

解析：思想为对字符只用判断下一个字符而不用整体判断，因为会遍历

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int len=s.length();
        for(int i=0;i

异位字符串：
给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:
输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”],
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]

对于比较：
利用 char c[]=strs[i].toCharArray();
Arrays.sort©;
String str=String.valueOf©化为有序字符串再进行map.containsKey(str)

class Solution {
    public List> groupAnagrams(String[] strs) {
        Map map=new HashMap<>();
        List> list=new LinkedList<>();
        int len=strs.length;
        int count=0;
        for(int i=0;i list1=new LinkedList<>();
                list1.add(strs[i]);
                list.add(list1);
                map.put(str,count);count++;
            }
        }
        return list;
    }
}

for (char c : s.toCharArray()) count[c - ‘a’]++;
sb.append(’#’);
将26个字符化为26个数字用#嵌套，再利用ans.containsKey(key)判断

class Solution {
    public List> groupAnagrams(String[] strs) {
        if (strs.length == 0) return new ArrayList();
        Map ans = new HashMap();
        int[] count = new int[26];
        for (String s : strs) {
            Arrays.fill(count, 0);
            for (char c : s.toCharArray()) count[c - 'a']++;

            StringBuilder sb = new StringBuilder("");
            for (int i = 0; i < 26; i++) {
                sb.append('#');
                sb.append(count[i]);
            }
            String key = sb.toString();
            if (!ans.containsKey(key)) ans.put(key, new ArrayList());
            ans.get(key).add(s);
        }
        return new ArrayList(ans.values());
    }
}

字符串的字典距离：
给定一个单词列表和两个单词 word1 和 word2，返回列表中这两个单词之间的最短距离。
示例:
假设 words = [“practice”, “makes”, “perfect”, “coding”, “makes”]
输入: word1 = “coding”, word2 = “practice”
输出: 3
输入: word1 = “makes”, word2 = “coding”
输出: 1
注意:
你可以假设 word1 不等于 word2, 并且 word1 和 word2 都在列表里。

class Solution {
   public int shortestDistance(String[] words, String word1, String word2) {
    int i1 = -1, i2 = -1;
    int minDistance = words.length;
    int currentDistance;
    for (int i = 0; i < words.length; i++) {
        if (words[i].equals(word1)) {
            i1 = i;
        } else if (words[i].equals(word2)) {
            i2 = i;
        }

        if (i1 != -1 && i2 != -1) {
            minDistance = Math.min(minDistance, Math.abs(i1 - i2));
        }
    }
    return minDistance;
}
}

多次调用：

class WordDistance {
    HashMap> map;
    public WordDistance(String[] words) {
        map=new HashMap>();
        for(int i=0;i list;
            if(!map.containsKey(words[i])){
                list=new ArrayList();
                map.put(words[i],list);
            }
            list=map.get(words[i]);
            list.add(i);
            map.put(words[i],list);
        }
    }
    public int shortest(String word1, String word2) {
        ArrayList list1=map.get(word1);
        ArrayList list2=map.get(word2);
        int i=0,j=0;
        int num1=0,num2=0,minlength=Integer.MAX_VALUE;
        while(inum2)j++;
            else i++;
        }
        return minlength;
    }
}

移位异构字符串：
给定一个字符串，对该字符串可以进行 “移位” 的操作，也就是将字符串中每个字母都变为其在字母表中后续的字母，比如：“abc” -> “bcd”。这样，我们可以持续进行 “移位” 操作，从而生成如下移位序列：

“abc” -> “bcd” -> … -> “xyz”
给定一个包含仅小写字母字符串的列表，将该列表中所有满足 “移位” 操作规律的组合进行分组并返回。
示例：
输入: [“abc”, “bcd”, “acef”, “xyz”, “az”, “ba”, “a”, “z”]
输出:
[
[“abc”,“bcd”,“xyz”],
[“az”,“ba”],
[“acef”],
[“a”,“z”]
]

class Solution {
    public List> groupStrings(String[] strings) {
        HashMap> map=new HashMap<>(); 
        for(int i=0;i list=new LinkedList<>();
            if(c.length==1){
                result="a";
                if(!map.containsKey(result)){
                    map.put(result,list);
                }
                map.get(result).add(str);
            }
            else{
                for(int j1=0,j2=1;j2

无公共字母的字符串乘积
给定一个字符串数组 words，找到 length(word[i]) * length(word[j]) 的最大值，并且这两个单词不含有公共字母。你可以认为每个单词只包含小写字母。如果不存在这样的两个单词，返回 0。

示例 1:

输入: [“abcw”,“baz”,“foo”,“bar”,“xtfn”,“abcdef”]
输出: 16
解释: 这两个单词为 “abcw”, “xtfn”。
示例 2:

输入: [“a”,“ab”,“abc”,“d”,“cd”,“bcd”,“abcd”]
输出: 4
解释: 这两个单词为 “ab”, “cd”。
示例 3:

输入: [“a”,“aa”,“aaa”,“aaaa”]
输出: 0
解释: 不存在这样的两个单词。

class Solution {
    public int maxProduct(String[] words) {
        int wlength = words.length;
        int[] arr = new int[wlength];
        for(int i = 0; i < wlength; ++i){
            int length = words[i].length();
            for(int j = 0; j < length; ++j){
                arr[i] |= 1 << (words[i].charAt(j) - 'a');
            }
        }
        int ans = 0;
        for(int i = 0; i < wlength; ++i){
            for(int j = i + 1; j < wlength; ++j){
                if((arr[i] & arr[j]) == 0){
                    int k = words[i].length() * words[j].length();
                    ans = ans < k ? k : ans;
                }
            }
        }
        return ans;
    }
}