是否字符串A包含字符串B的所有字母（区分大小写，算个数，不算顺序）

是否字符串A包含字符串B的所有字母（区分大小写，算个数，不算顺序），比如：

举例说明

字符串A：aaabcdefgamm
字符串B：mama
比较结果：成功，A包含B。因为A有四个a和两个m。

字符串A：aaabcdefga
字符串B：mama
比较结果：失败，A不包含B。因为A没有m。

字符串A：aaabcdefgamM
字符串B：mama
比较结果：失败，A不包含B。因为A只有一个m（另外一个是M）。

字符串A：aaabcdefgm
字符串B：mama
比较结果：失败，A不包含B。因为A只有一个m，而B有两个m。

最直观的想法就是轮询字符串B，看看每一个字母是否都在字符串A中存在

public boolean q1(String a, String b){
    if(a != null && !a.isEmpty() && b != null && !b.isEmpty()) {
        boolean result = true;
        int index;
        StringBuffer source = new StringBuffer();
        StringBuffer sb = new StringBuffer();
        source.append(a);
        for (int i = 0; i < b.length(); i++) {
            String letter = String.valueOf(b.charAt(i));
            index = source.indexOf(letter);
            if (index > -1) {
                sb.delete(0, sb.length());
                sb.append(source.substring(0, index)).append(source.substring(index + 1));
                source.delete(0, source.length());
                source.append(sb);
            } else {
                return false;
            }
        }
        return result;
    }else{
        return false;
    }
}

这个算法只用了一个轮询，感觉它的BigO应该是O(n)，其实则不然，别忘了我们用了indexOf这个方法，看String.java就知道，indexOf内部也是通过一个轮询来实现的，所以这个算法的BigO应该是O(n$^2$)。

我们来尝试优化这个算法，不要在循环内再加循环。把这两个字符串变成整型数组，’A’的ASCII码是65，’z’是122，这样我们建立一个长度为60（>122-65）的数组即可，数组的index就是ASCII码（0就是’A’），数组的内容就是字母数量，比如lettersA[0] = 5，就表示字符串A中含有5个大写的字母A。

public boolean q2(String a, String b){
    if(a != null && !a.isEmpty() && b != null && !b.isEmpty()) {
        boolean result = true;
        int[] lettersA = new int[60];
        int[] lettersB = new int[60];
        for (int i = 0; i < b.length(); i++) {
            lettersB[b.charAt(i) - 'A']++;
        }
        for (int i = 0; i < a.length(); i++) {
            lettersA[a.charAt(i) - 'A']++;
        }
        for (int i = 0; i < lettersA.length; i++) {
            if (lettersA[i] < lettersB[i]) {
                return false;
            }
        }
        return result;
    }else{
        return false;
    }
}

该算法的时间复杂度为三个轮询的和（注意，是非嵌套轮询）3n，所以它的BigO是O(n)。

看看比较结果吧

public static void main(String[] args) {
        int count = 500000;
        boolean result1 = false,result2 = false;
        String a = "aabbahdhdghghdhdfghgGGHDVBNNSDfhgcccccqqqcczzzzzccc" +
                   "cccccccdfhdgfhgfhgnnnQQnnnnnnn" +
                   "nfhfghghghgfuokekaddQQQQdadddffff";       
        String b = "ghdhdfgcccfffgbzbggggQ";

        long start = System.currentTimeMillis();
        for(int i=0; i<count; i++) {
            result1 = q1(a, b);
        }
        long t1 = System.currentTimeMillis();
        System.out.println(t1 - start);

        for(int i=0; i<count; i++) {
            result2 = q2(a, b);
        }
        long t2 = System.currentTimeMillis();
        System.out.println(t2 - t1);

        System.out.println("q1 = " + result1);
        System.out.println("q2 = " + result2);
    }

1809
110
q1 = true
q2 = true