字符串处理:
翻转字符串
同构字符串
异位字符串:
移位异构字符串
字符串的字典距离
无公共字母的字符串乘积
翻转字符串
给定一个字符串,逐个翻转字符串中的每个单词。
示例 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;
}
}