程序员编程艺术学习笔记(二)字符串是否包含问题

程序员编程艺术原文出自大神:v_JULY_v  地址:http://blog.csdn.net/v_july_v/article/category/784066

c++实现.敬请膜拜。

字符串问题虽基础，变化却是令人发指=—=，随便改改就能让人纠结半天。。继续砸瓷实基础，基础，基础。

原文C++实现，现将自己实现的java版本记录如下，不定期更新，自我监督，自我监督。

 程序员编程艺术：第二章、字符串是否包含问题

题目描述：
假设这有一个各种字母组成的字符串A，和另外一个字符串B，字符串里B的字母数相对少一些。什么方法能最快的查出所有小字符串B里的字母在大字符串A里都有？

比如，如果是下面两个字符串：
String 1: ABCDEFGHLMNOPQRS
String 2: DCGSRQPO
答案是true，所有在string2里的字母string1也都有。
  
如果是下面两个字符串：  
String 1: ABCDEFGHLMNOPQRS   
String 2: DCGSRQPZ  
答案是false，因为第二个字符串里的Z字母不在第一个字符串里。

    点评：
    1、题目描述虽长，但题意简单明了，就是给定一长一短的俩个字符串A，B，假设A长B短，现在，要你判断B是否包含在字符串A中，即B?(-A。

    2、题意虽简单，但实现起来并不轻松，且当如果面试官步步紧逼，一个一个否决你能想到的方法，要你给出更好、最好的方案时，你恐怕就要伤不少脑筋了。

    ok，在继续往下阅读之前，您最好先想个几分钟，看你能想到的最好方案是什么，是否与本文最后实现的方法一致。

1.1、O（n*m）的轮询方法

判断string2中的字符是否在string1中?：
String 1: ABCDEFGHLMNOPQRS
String 2: DCGSRQPO

    判断一个字符串是否在另一个字符串中，最直观也是最简单的思路是，针对第二个字符串string2中每一个字符，一一与第一个字符串string1中每个字符依次轮询比较，看它是否在第一个字符串string1中。

如下:

import java.util.Scanner;


public class StrIn {
	public static void main(String args[]){
		String str1="abcdefghijklmnopq";
		String str2="dcfehgopq";
		String str3="abcdeertyuiop";
		//Scanner scanner=new Scanner(System.in);
		//String input=scanner.nextLine();
		if(isInclude(str1,str3)){
			System.out.println("完全包含");
		}else{
			System.out.println("不完全包含");
		}
	}
	
	public static boolean isInclude(String str1,String str2){
		char[] array1=str1.toCharArray();
		char[] array2=str2.toCharArray();
		boolean include = false;
		for(int i=0;i<array2.length;i++){
			
			for(int j=0;j<array1.length;j++){
				//注释可把对比过程打印出来
				//System.out.println(array1[j]);
				//System.out.println(array2[j]);
				if(array2[i]==array1[j]){
					include=true;
					System.out.println("等 true");
					break;
				}else{
				System.out.println("不等continue");
				include=false;
				}	
				
			}
			if(include ==false){
				System.out.print("不包含因为"+array2[i]);
				return false;
			}
			}
		
		return true;
	}
}

 

 

1.2、O(mlogm)+O(nlogn)+O(m+n)的排序方法
    一个稍微好一点的方案是先对这两个字符串的字母进行排序，然后同时对两个字串依次轮询。两个字串的排序需要(常规情况)O(m log m) + O(n log n)次操作，之后的线性扫描需要O(m+n)次操作。

    同样拿上面的字串做例子，将会需要16*4 + 8*3 = 88，再加上对两个字串线性扫描的16 + 8 = 24的操作。(随着字串长度的增长，你会发现这个算法的效果会越来越好)

如果时间不足，考虑自带字符串排序方式:

	public static String sort(String str){
		
		char []array=str.toCharArray();
		Arrays.sort(array);
		String res=new String(array);
		return res;
		
	}

时间充裕就手写吧~原文是用最常用的快速排序

 

第二节、寻求线性时间的解法
2.1、O（n+m）的hashtable的方法
    上述方案中，较好的方法是先对字符串进行排序，然后再线性扫描，总的时间复杂度已经优化到了：O（m+n），貌似到了极限，还有没有更好的办法列?

    我们可以对短字串进行轮询（此思路的叙述可能与网上的一些叙述有出入，因为我们最好是应该把短的先存储，那样，会降低题目的时间复杂度），把其中的每个字母都放入一个Hashtable里(我们始终设m为短字符串的长度，那么此项操作成本是O(m)或8次操作)。然后轮询长字符串，在Hashtable里查询短字符串的每个字符，看能否找到。如果找不到，说明没有匹配成功，轮询长字符串将消耗掉16次操作，这样两项操作加起来一共只有8+16=24次。
    当然，理想情况是如果长字串的前缀就为短字串，只需消耗8次操作，这样总共只需8+8=16次。

 

 

注:此实现先存储了长字符串，如按原文叙述存储短字符也OK，但是有关时间复杂度的降低需要实际验证，也许存储短字符会更低。

 

public static void isIncludeHash2(String str1,String str2){
		char[] array1=str1.toCharArray();
		char[] array2=str2.toCharArray();
		int m=0;
		Hashtable<Character,Integer> table=new Hashtable<Character,Integer>();
		for(int i=0;i<array1.length;i++){
			table.put(array1[i], 0);
			
		}
		
		
		for(int j=0;j<array2.length;j++){
			if(!table.containsKey(array2[j])){
				System.out.println("不完全包含");
				break;
				}
			if(j==array2.length-1){
				System.out.println("完全包含");
				}
		}
		

 

 

注 :此处实现存在理想化问题，如果两个字符串各有重复字符，会产生bug。个人实现为保证正确和通用性，遍历了最后的value，以获得准确的结果。

   或如梦想天窗所说： 我之前用散列表做过一次，算法如下：
 1、hash[26]，先全部清零，然后扫描短的字符串，若有相应的置1，
 2、计算hash[26]中1的个数，记为m
 3、扫描长字符串的每个字符a；若原来hash[a] == 1 ，则修改hash[a] = 0，并将m减1；若hash[a] == 0，则不做处理
 4、若m == 0 or 扫描结束，退出循环。

 

public static void isIncludeHash(String str1,String str2){
		char[] array1=str1.toCharArray();
		char[] array2=str2.toCharArray();
		int m=0;
		Hashtable<Character,Integer> table=new Hashtable<Character,Integer>();
		for(int i=0;i<array2.length;i++){
			table.put(array2[i], 0);
			
		}
		//原版处理方式为m++，m--方式，但在两个字串各有重复时未能正确判断，留待后续修正
		//m=table.size();
		
		for(int j=0;j<array1.length;j++){
			if(table.containsKey(array1[j])){
				table.remove(array1[j]);
				table.put(array1[j], 1);
				//m--
				}
		}

		for(int i=0;i<array2.length;i++){
		if(table.get(array2[i])==0){
			m++;
			//此处可以增加break方式,一旦m存在0，则存在未被改变的字符，即str1中不存在的，如不需要返回全部不存在的字符，节省时间，此处退出即可
			break;
		}
		
		}
		
		if(m==0){
			System.out.println("完全包含");
		}else{
			System.out.println("不完全包含");
		}
		}
	

编写测试类:

 

public class StrIn {
	public static void main(String args[]){
		String str1="abcdefghijklmnopq";
		String str2="ddcfehgoph";
		String str3="abcdeertyuiop";
		//Scanner scanner=new Scanner(System.in);
		//String input=scanner.nextLine();
		if(isInclude(str1,str3)){
			System.out.println("完全包含");
		}else{
			System.out.println("不完全包含");
		}
		isIncludeHash1(str1,str2);
		isIncludeHash1(str1,str3);	
		isIncludeHash2(str1,str2);
		isIncludeHash2(str1,str3);
		}}

最后的素数方法，其实结论上来说，通用性（需要找至少26个素数，还不包含大小写和数字）和时间消耗(并不一定少)上存在一些不确定因素。

不过开始看到这个方式我真的感觉呵呵。。如此神奇- - 算是开阔思路的方式。挺有意思的。

实现就暂时不做了，感觉起来通用性不够好，暂时不作为常用技能吧。

 

第三节、O（n）到O（n+m）的素数方法

    我想问的是，还有更好的方案么?
    你可能会这么想：O(n+m)是你能得到的最好的结果了，至少要对每个字母至少访问一次才能完成这项操作，而上一节最后的俩个方案是刚好是对每个字母只访问一次。

    ok，下面给出一个更好的方案：
    假设我们有一个一定个数的字母组成字串，我给每个字母分配一个素数，从2开始，往后类推。这样A将会是2，B将会是3，C将会是5，等等。现在我遍历第一个字串，把每个字母代表的素数相乘。你最终会得到一个很大的整数，对吧？
    然后——轮询第二个字符串，用每个字母除它。如果除的结果有余数，这说明有不匹配的字母。如果整个过程中没有余数，你应该知道它是第一个字串恰好的子集了。

思路总结如下：
1.定义最小的26个素数分别与字符'A'到'Z'对应。
2.遍历长字符串，求得每个字符对应素数的乘积。
3.遍历短字符串，判断乘积能否被短字符串中的字符对应的素数整除。
4.输出结果。

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

    不过，正如原文中所述：“现在我想告诉你 —— Guy的方案在算法上并不能说就比我的好。而且在实际操作中，你很可能仍会使用我的方案，因为它更通用，无需跟麻烦的大型数字打交道。但从”巧妙水平“上讲，Guy提供的是一种更、更、更有趣的方案。”

#include <iostream>  
#include <string>  
#include "BigInt.h"  
using namespace std;  
  
// 素数数组  
int primeNumber[26] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,  
                       61, 67, 71, 73, 79, 83, 89, 97, 101};  
  
int main()  
{  
    string strOne = "ABCDEFGHLMNOPQRS";  
    string strTwo = "DCGSRQPOM";  
 
   // 这里需要用到大整数  
   CBigInt product = 1;   //大整数除法的代码，下头给出。  

   // 遍历长字符串，得到每个字符对应素数的乘积  
   for (int i = 0; i < strOne.length(); i++)  
   {  
     int index = strOne[i] - 'A';  
       product = product * primeNumber[index];  
    }  
 
  // 遍历短字符串  
   for (int j = 0; j < strTwo.length(); j++)  
    {  
      int index = strTwo[j] - 'A';  
  
      // 如果余数不为0，说明不包括短字串中的字符，跳出循环  
      if (product % primeNumber[index] != 0)  
           break;  
   }  
 
  // 如果积能整除短字符串中所有字符则输出"true"，否则输出"false"。  
   if (strTwo.length() == j)  
        cout << "true" << endl;  
    else  
        cout << "false" << endl;  
    return 0;  
}  

 

上述程序待改进的地方：
1.只考虑大写字符，如果考虑小写字符和数组的话，素数数组需要更多素数
2.没有考虑重复的字符，可以加入判断重复字符的辅助数组。