《leetCode》：Group Anagrams

题目

Given an array of strings, group anagrams together.

For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"],
Return:

[
["ate", "eat","tea"],
["nat","tan"],
["bat"]
]
Note:
For the return value, each inner list's elements must follow the lexicographic order.
All inputs will be in lower-case.

思路一

此思路比较传统，就是从字符串数组从头开始遍历分别找到与第i个字符串含相同字符的所有字符串，并组合为一个List加入到List< List>中；最后对每个List的字符串按字典进行排序。时间复杂度为O(n^2)

package com.wrh.leetcode;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Solution_1 {
public  String my_sort(String str){
char[] s1 = str.toCharArray();
//System.out.println(s1);
for(int i=0;i<s1.length;i++){
for(int j=0;j<i;j++){
if(s1[i]<s1[j]){
char temp = s1[i];
s1[i] = s1[j];
s1[j] = temp;
}
}
}
return String.valueOf(s1);
}
public List<List<String>> groupAnagrams(String[] strs) {
List<List<String>> list=new ArrayList<List<String>>();
if(strs==null){
return list;
}
for(int i=0;i<strs.length;i++){
List<String > list1=new ArrayList<String>();
if(strs[i]!=""){
list1.add(strs[i]);
}
else{
continue;
}
String tempStr1=my_sort(strs[i]);
for(int j=i+1;j<strs.length;j++){
if(tempStr1.equals(my_sort(strs[j]))){
list1.add(strs[j]);
strs[j]="";
}
}
list.add(list1);
}
//将list中每个子list中的元素进行按字典排序。
for(List tempList:list){
Collections.sort(tempList);
}
return list;
}
public static void main(String []args){
Solution_1 s=new Solution_1();
String[] strs=new String[]{"eat","ate","tea","nat","tan","ban"};
List<List<String>> l=s.groupAnagrams(strs);
for(List list:l){
System.out.println(list.toString());
}
}
}

代码报超时错误



因此，只能寻找更好的方法。

改进一

将自己写的my_sort换成了系统自带的。但是还是报超时错误。因此还是得继续改进，将时间复杂度O(n^2)降低为n的线性。

public class Solution {
public  String my_sort(String str){
char[] s1 = str.toCharArray();
Arrays.sort(s1);
return String.valueOf(s1);
}
public List<List<String>> groupAnagrams(String[] strs) {
Arrays.sort(strs);
List<List<String>> list=new ArrayList<List<String>>();
if(strs==null){
return list;
}
for(int i=0;i<strs.length;i++){
List<String > list1=new ArrayList<String>();
if(strs[i]!=""){
list1.add(strs[i]);
}
else{
continue;
}
String tempStr1=my_sort(strs[i]);
for(int j=i+1;j<strs.length;j++){
if(tempStr1.equals(my_sort(strs[j]))){
list1.add(strs[j]);
strs[j]="";
}
}
list.add(list1);
}
return list;
}
}

改进二

思路还是原来的思路，只是这里借用了Map，因此，这样就将O(n^2)降为了O(n);

实现代码如下

public List<List<String>> groupAnagrams(String[] strs) {
if(strs==null){
return null;
}
//借用Map来做
Arrays.sort(strs);//对字符数组进行排序
int len=strs.length;
Map<String,List<String>> map=new HashMap<String ,List<String>>();
for(int i=0;i<len;i++){
String curString=strs[i];
//先将此字符串转化为char数组，然后将其排序。这样就导致所有含有相同字符的字符串都是一个key。
char ch[]=curString.toCharArray();
Arrays.sort(ch);
String key=String.valueOf(ch);
List<String> list=map.getOrDefault(key, new ArrayList<String>());//没有就返回默认的List
list.add(curString);
map.put(key, list);
}
return new ArrayList<>(map.values());
}