微软面试100题算法(1)实现一个字符匹配

问题:

实现一个挺高级的字符匹配算法:
给一串很长字符串,要求找到符合要求的字符串,例如目的串:123
1******3***2 ,12*****3这些都要找出来
其实就是类似一些和谐系统。。。。。

分析:

这题的真正意思就是,给你一个目标串,如“123”,只要一个字符串里面同时包含1、2和3,那么这个字符串就匹配了。系统越和谐,说明错杀的可能行也就越大。加入目标串的长度为m,模式串的长度为n,我们很容易想到O(mn)的算法,就是两遍for循环搞定(就是找一个子串)。那么有没有更快的方法呢?

   我们考虑问题的时候,如果想时间变得快,有一种方法就叫做“空间换时间”。哈希表是一种比较复杂的数据结构。由于比较复杂,STL中没有实现哈希表,因此需要我们自己实现一个。但由于本题的特殊性,我们只需要一个非常简单的哈希表就能满足要求。由于字符(char)是一个长度为8的数据类型,因此总共有可能256 种可能。于是我们创建一个长度为256的数组,每个字母根据其ASCII码值作为数组的下标对应数组的对应项,而数组中存储的0、1对应每个字符是否出现。这样我们就创建了一个大小为256,以字符ASCII码为键值的哈希表。(并不仅限于英文字符,所以这里要考虑256种可能)。

       知道了这点,我们可以构建一个数组来统计模式串中某个字符是否出现,然后在对目标串进行扫描,看看对应的所有位上是否出现,从而判断是否匹配。分析一下复杂度,大概是O(m+n)。

代码如下:

[cpp] 
view plain
copy

  1. //强大的和谐系统  
  2. int is_contain(char *src, char *des)  
  3. {  
  4.     //创建一个哈希表,并初始化  
  5.     const int tableSize = 256;  
  6.     int hashTable[tableSize];  
  7.     int len,i;  
  8.   
  9.     for(i = 0; i < tableSize; i++)  
  10.         hashTable[i] = 0;  
  11.   
  12.     len = strlen(src);  
  13.     for(i = 0; i < len; i++)  
  14.         hashTable[src[i]] = 1;  
  15.   
  16.     len = strlen(des);  
  17.     for(i = 0; i < len; i++)  
  18.     {  
  19.         if(hashTable[des[i]] == 0)  
  20.             return 0;         //匹配失败  
  21.     }  
  22.     return 1;    //匹配成功  
  23. }  



与此题类似:给一个很长的字符串str, 还有一个字符集比如{a,b,c},找出str包含{a,b,c}的最短子串,要求O(n)。

[cpp] 
view plain
copy

  1. /* 
  2. 用两个变量 front,rear 指向一个的子串区间的头和尾(当然,开始时front和rear都指向字符串开始处)。 
  3. 用一个int cnt[255]={0}记录当前这个子串里字符集a,b,c各自的个数,一个变量count记录字符集里有多少个了 
  4. rear 一直加,更新cnt[]和count的值,直到count等于字符集个数 
  5. 然后front++,直到cnt[]里某个字符个数为0(front 开始的部分有可能和后面的重复,所以front要加到某个字符个数为0), 
  6. 这样就找到一个符合条件的字串了,继续下去,可以求出所有符合条件的串,同时可以求出满足条件最短子串 
  7.  
  8. */  
  9.   
  10. #include <iostream>  
  11. using namespace std;  
  12.   
  13. void MinSubString( char *src, char *des )  
  14. {  
  15.     int min=1000;//找最短子串  
  16.     int minfront=0;//最短子串开始位置  
  17.     int minrear=0;//最短子串结束位置  
  18.     int front,rear;  
  19.     front=rear=0;  
  20.     int len=strlen(des);  
  21.     int hashtable[255]={0};  
  22.     int cnt[255]={0};  
  23.     int cnt2[255]={0};  
  24.     for(int i=0; i<len; i++)//将字符集里的字符映射到hashtable数组中,方便判断src中的某个字符是否在字符集中  
  25.         hashtable[*(des+i)]=1;  
  26.     int count=0;  
  27.     char *p=src;  
  28.     while( *(p+rear) !=‘\0’)  
  29.     {  
  30.         if(hashtable[*(p+rear)]==1)//rear当前字符在字符集中  
  31.         {  
  32.             if(cnt2[*(p+rear)]==0)//判断是否是本子串中第一次检索到此字符,由count统计字符集中已出现的字符数  
  33.             {  
  34.                 count++;  
  35.                 cnt[*(p+rear)]++;  
  36.                 cnt2[*(p+rear)]++;  
  37.                 if(count == len)//字符集中的字符在本子串中都已检索到  
  38.                 {  
  39.                     while(1)  
  40.                     {  
  41.                         if(hashtable[*(p+front)]==1)//front当前字符在字符集中  
  42.                         {  
  43.                             cnt[*(p+front)]–;  
  44.                             if(cnt[*(p+front)]==0)//字符集中某个字符为0,此时front到rear所指字符串即为符合条件的子串  
  45.                             {  
  46.                                 for(i=front; i<=rear; i++)//打印此子串  
  47.                                     cout<<*(p+i);  
  48.                                 cout<<endl;  
  49.                                 if(rear-front+1<min)  
  50.                                 {  
  51.                                     min=rear-front+1;  
  52.                                     minrear=rear;  
  53.                                     minfront=front;  
  54.                                 }  
  55.                                 //开始另一个串的检索时,要将count和cnt2[]清零。cnt[]不用变  
  56.                                 count=0;  
  57.                                 for(i=0; i<255; i++)  
  58.                                     cnt2[i]=0;  
  59.                                 front++;  
  60.                                 break;                                
  61.                             }                 
  62.                         }  
  63.                         front++;  
  64.                     }  
  65.                 }  
  66.             }  
  67.             else  
  68.             {  
  69.                 cnt[*(p+rear)]++;     
  70.                 cnt2[*(p+rear)]++;    
  71.             }  
  72.         }//当前字符不在字符集中  
  73.         rear++;  
  74.     }  
  75.   
  76.   
  77.     cout<<“最短子串:”;  
  78.     for(i=minfront ; i<=minrear; i++)  
  79.         cout<<*(p+i);  
  80.     cout<<endl;  
  81.   
  82.   
  83.   
  84.   
  85.   
  86. }  
  87.   
  88. void main()  
  89. {  
  90.     char *src=“ab1dkj2ksjf3ae32ks1iji2sk1ksl3ab;iksaj1223”;  
  91. //  char *src=”2sk1ksl3ab;iksaj1223″;  
  92.     char *des=“123”;  
  93.     MinSubString( src, des );  
  94.   
  95.   
  96. }  
    原文作者:zhuanshenweiliu
    原文地址: https://blog.csdn.net/zhuanshenweiliu/article/details/37722605
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞