字符串包含

题目描述：

给定两个分别由字母（全为大写字母）组成的字符串A和字符串B，a串长度大于b串，看b串是否包含再a串中

解法分析：

1.暴力解法，判断string2中的字符是否在string1中?最直观也是最简单的思路是，针对string2中每一个字符，逐个与string1中每个字符比较，看它是否在String1中。

 public static boolean ContainStr(String str1, String str2) {
        char[] a = str1.toCharArray();
        char[] b = str2.toCharArray();
        for (int i = 0; i < str1.length(); i++) {
            for (int j = 0; j < str2.length(); j++) {
                if (a[i] == b[j] && a.length > b.length) {
                    return true;
                }
            }
        }
        return false;
    }

2. 排序后匹配法：将a串和b串排序，并遍历a串，若a[i] > b[j]或a串找到最后也没有找到，则false，若a[i] < b[j],则i++；若a[i] = b[j]，j++遍历b串的下一个字符（用小串比较大串），返回true.两个字串的排序需要(常规情况)O(m log m) + O(n log n)次操作，之后的线性扫描需要O(m+n)次操作。排序可用最常用的快速排序或Java的Array.sort()方法。

private static boolean ConstainStrPro(String str1, String str2) {
        //给字符串排序,然后再同时对两个字串依次轮询移动下标进行比较
        char[] a = str1.toCharArray();
        char[] b = str2.toCharArray();
        Arrays.sort(a);
        Arrays.sort(b);
        for (int i = 0, j = 0; j < b.length; ) {
            while (i < a.length && (a[i] < b[j])) {
                i++;
            }
            if (i >= a.length || (a[i] > b[j])) {
                return false;
            } else {
                j++;
                return true;
            }
        }
        return true;
    }

3.素数相乘法，假设有一个仅由字母组成字串，让每个字母与一个素数对应，从2开始，往后类推，A对应2，B对应3，C对应5，……。遍历第一个字串，把每个字母对应素数相乘。最终会得到一个整数。利用上面字母和素数的对应关系，对应第二个字符串中的字母，然后轮询，用每个字母对应的素数除前面得到的整数。如果结果有余数，说明结果为false。如果整个过程中没有余数，则说明第二个字符串是第一个的子集了（判断是不是真子集，可以比较两个字符串对应的素数乘积，若相等则不是真子集）。思路总结如下：

1. 按照从小到大的顺序，用26个素数分别与字符’A’到’Z’一一对应。
2. 遍历长字符串，求得每个字符对应素数的乘积。
3. 遍历短字符串，判断乘积能否被短字符串中的字符对应的素数整除。
4. 输出结果。

如前所述，算法的时间复杂度为O(m+n)的最好的情况为O(n)（遍历短的字符串的第一个数，与长字符串素数的乘积相除，即出现余数，便可退出程序，返回false），n为长字串的长度，空间复杂度为O(1)。

//长字符串中每个字母对应数组中的一个素数，将每个字符对应的素数相乘得到一个整数，然后遍历短字符串，
    // 用短字符串中每个字母对应的素数除前面得到的整数若能被整除则true，否则false
    private static boolean ContainStrmax(String str1, String str2) {
        int[] nums = {2, 3, 5, 7};//26个素数对应‘A-Z’26个字母
        int temp = 1;
        char[] a = str1.toCharArray();
        char[] b = str2.toCharArray();
        for (int i = 0; i < a.length; i++) {
            int x = nums[a[i] - 'A'];
            temp *= x;
        }
        for (int j = 0; j < b.length; j++) {
            int x = nums[b[j] - 'A'];
            if ((temp % x) == 0) {
                return true;
            }
        }
        return false;
    }

 4.先把长字符串a中的所有字符都放入一个Hashtable里，然后轮询短字符串b，看短字符串b的每个字符是否都在Hashtable里，如果都存在，说明长字符串a包含短字符串b，否则，说明不包含。再进一步，我们可以对字符串A，用位运算（26bit整数表示)计算出一个“签名”，再用B中的字符到A里面进行查找，这个方法的实质是用一个整数代替了hashtable，空间复杂度为O(1)，时间复杂度还是O(n + m)。例如：假设A串为A、B，B串为B，hash为0001或上0010为0011（或运算），然后遍历B串，为0010，与运算为0010不为0，返回true。若B串为C ，0100，与运算为0，返回false。

    //利用hash来存储A串中的字母，利用位运算来操作B串中的字母
    private static boolean ContainStrPromax(String str1, String str2) {
        int hash = 0;
        char[] a = str1.toCharArray();
        char[] b = str2.toCharArray();
        for (int i = 0; i < a.length; i++) {
            hash |= (1 << (a[i] - 'A'));
        }
        for (int n = 0; n < b.length; n++) {
            if ((hash & (1 << (b[n] - 'A'))) == 0) {
                return false;
            }
        }
        return true;
    }

参考书籍《编程之法：面试和算法心得》。