lintcode：乱序字符串

描述：

给出一个字符串数组S，找到其中所有的乱序字符串(Anagram)。如果一个字符串是乱序字符串，那么他存在一个字母集合相同，但顺序不同的字符串也在S中。

实现：

public class Solution {
    /**
     * @param strs: A list of strings
     * @return: A list of strings
     */
    public List<String> anagrams(String[] strs) {
        List<String> result=new ArrayList<>();
        if(strs==null || strs.length==0){
        	return result;
        }       
        HashMap<String, String> h=new HashMap<>();
        for(int i=0; i<strs.length; i++){
        	String st=mySort(strs[i]);
        	if(h.get(st)!=null){
        		result.add(strs[i]);
        		h.put(st, h.get(st).replace("0", "1"));
        	}
        	else{
        		h.put(st, strs[i]+"0");
        	}
        }
        for(String st: h.keySet()){
        	String t=h.get(st);
        	if(t.charAt(t.length()-1)=='1'){
        		result.add(t.substring(0, t.length()-1));
        	}
        }
        return result;
    }
	
	private String mySort(String str){
		if(str==null || str=="") return str;
		char[] c=str.toCharArray();
		Arrays.sort(c);
		StringBuilder sb=new StringBuilder();
		for(int i=0; i<c.length; i++){
			sb.append(c[i]);
		}
		return sb.toString();
	}
}

个人感觉这个题目，lintcode给出的测试用例有点问题，因为按照题干中给出的乱序字符串的定义（字符集相同但顺序不同），两个相同的字符串不是乱序字符串，比如字符串数组["abc","abc","bcd","dcb"]，最后应该只输出["bcd","dcb"]，但是lintcode的测试用例里面把"abc"也作为乱序字符串了。上面的代码是能够完成这个功能的，下面在此基础上修改的代码可以消除这个情况：

public class Anagrams {
	public List<String> anagrams(String[] strs) {
        List<String> result=new ArrayList<>();
        if(strs==null || strs.length==0){
        	return result;
        }
        boolean flag=false;
        Set<String> s=new HashSet<>();//消除相同的字符串
        HashMap<String, Integer> hCount=new HashMap<>();//记录相同的字符串出现的次数
        for(int i=0; i<strs.length; i++){
        	if(flag && strs[i].length()==0){
        		result.add("");
        	}
        	if(strs[i].length()==0){
        		flag=true;        		
        	}
        	if(hCount.get(strs[i])!=null){
        		hCount.put(strs[i], hCount.get(strs[i])+1);
        	}
        	else{
        		hCount.put(strs[i], 1);
        	}
        	s.add(strs[i]);
        }
        if(flag){
        	result.add("");
        }
        HashMap<String, String> h=new HashMap<>();
        for(String str: s){
        	String st=mySort(str);
        	if(h.get(st)!=null){
        		for(int i=0; i<hCount.get(str); i++){
        			result.add(str);
        		}
        		h.put(st, h.get(st).replace("0", "1"));
        	}
        	else{
        		h.put(st, str+"0");
        	}
        }
        for(String st: h.keySet()){
        	String t=h.get(st);
        	if(t.charAt(t.length()-1)=='1'){
        		for(int i=0; i<hCount.get(t.substring(0, t.length()-1)); i++){
        			result.add(t.substring(0, t.length()-1));
        		}
        	}
        }
        return result;
    }
	
	private String mySort(String str){
		char[] c=str.toCharArray();
		Arrays.sort(c);
		StringBuilder sb=new StringBuilder();
		for(int i=0; i<c.length; i++){
			sb.append(c[i]);
		}
		return sb.toString();
	}

}

测试了几个样例，对于["abc","abc","bcd","dcb","bcd"]，输出["dcb", "bcd", "bcd"]，能够过滤掉重复的非乱序字符串，但是不会过滤掉重复的乱序字符串。