参考原文:http://blog.csdn.net/v_JULY_v/article/details/6347454
本文是基于以上链接修改,概括而来,并写出了自己的一些总结。
题目描述
给定两个分别由字母组成的字符串A和字符串B,字符串B的长度比字符串A短。请问,如何最快地判断字符串B中所有字母是否都在字符串A里?
为了简单起见,我们规定输入的字符串只包含大写英文字母,请实现函数bool StringContains(string &A, string &B)
比如,如果是下面两个字符串:
String 1:ABCD
String 2:BAD
答案是true,即String2里的字母在String1里也都有,或者说String2是String1的真子集。
如果是下面两个字符串:
String 1:ABCD
String 2:BCE
答案是false,因为字符串String2里的E字母不在字符串String1里。
同时,如果string1:ABCD,string 2:AA,同样返回true。
思路一:O(n*m)的轮询方法
看到这种是否包含的题目,第一反应就是遍历:将字符串2中的字符一个一个与字符串1中比较,如果不存在,就退出循环。
代码如下:
int CompareString(char *LongString,char *ShortString)
{
int LSize,SSize;
int i,j;
LSize = strlen(LongString);
SSize = strlen(ShortString);
for(i = 0;i < SSize;++i){
for(j = 0;j < LSize;++j){
if(LongString[j] == ShortString[i]){
break;
}
}
if(j == LSize){
printf("flase!");
return 0;
}
}
printf("true");
return 1;
}
假设n是字符串String1的长度,m是字符串String2的长度,那么此算法,需要O(n*m)次操作。显然,时间开销太大,应该找到一种更好的办法。
思路二:先排序再查找
当碰到数组或字符串问题,设计到查找,可利用先排序再查找的方法来提高时间复杂度!我们知道的常用的排序方法:
1:时间复杂度为O(nlogn):快速排序,堆排序,归并排序。一般选择快速排序,容易实现,且系数较小。
2:时间复杂度为O(n):基数排序,计数排序,桶排序。基数排序应用于多次排序,必须将3位数的数组进行排序。桶排序用于变化范围小的数组。由于我们用的只是字符,范围固定,选择计数排序更好。
方案一:快速排序O(mlogm)+O(nlogn)+O(m+n)
两个字串的排序需要(常规情况)O(m log m) + O(n log n)次操作,之后的线性扫描需要O(m+n)次操作。
//先排序,然后再比较
int partition(char *buf,int lo,int hi)
{
char key = buf[hi];
int i = lo - 1;
char temp;
for(int j = lo;j < hi;++j){
if(buf[j] < key){
i++;
temp = buf[i];
buf[i] = buf[j];
buf[j] = temp;
}
}
buf[hi] = buf[i+1];
buf[i+1] = key;
return i+1;
}
void QuickSort(char *buf,int lo,int hi)
{
if(lo < hi){
int k = partition(buf,lo,hi);
QuickSort(buf,lo,k-1);
QuickSort(buf,k+1,hi);
}
}
void CompareQuick(char *buf1,char *buf2)
{
int length_1 = strlen(buf1);
int length_2 = strlen(buf2);
int i=0,j;
for(j = 0;j < length_2;j++){
while(i < length_1 && buf1[i] < buf2[j]){ //这里判断条件不要写成buf1[i] != buf2[j],用小于号更减少时间复杂度
i++;
}
/* 由于上面的原因,这样写就不好了,因为可以提前就停止循环了!
if(i == length_1)
break;
*/
if(buf1[i] != buf2[j])
break;
}
if(j == length_2)
printf("true!");
else
printf("false!");
}
方案二:计数排序 O(n+m)
在排序的时候采用线性时间的计数排序方法,排序O(n+m),线性扫描O(n+m),总计时间复杂度为:O(n+m)+O(n+m)=O(n+m)。空间复杂度为O(n+m),即消耗了一定的空间。
#include <iostream>
#include <string>
using namespace std;
// 计数排序,O(n+m)
void CounterSort(string str, string &help_str)
{
// 辅助计数数组
int help[26] = {0};
// help[index]存放了等于index + 'A'的元素个数
for (int i = 0; i < str.length(); i++)
{
int index = str[i] - 'A';
help[index]++;
}
// 求出每个元素对应的最终位置
for (int j = 1; j < 26; j++)
help[j] += help[j-1];
// 把每个元素放到其对应的最终位置
for (int k = str.length() - 1; k >= 0; k--)
{
int index = str[k] - 'A';
int pos = help[index] - 1;
help_str[pos] = str[k];
help[index]--;
}
}
//线性扫描O(n+m)
void Compare(string long_str,string short_str)
{
int pos_long = 0;
int pos_short = 0;
while (pos_short < short_str.length() && pos_long < long_str.length())
{
// 如果pos_long递增直到long_str[pos_long] >= short_str[pos_short]
while (long_str[pos_long] < short_str[pos_short] && pos_long < long_str.length
() - 1)
pos_long++;
// 如果short_str有连续重复的字符,pos_short递增
while (short_str[pos_short] == short_str[pos_short+1])
pos_short++;
if (long_str[pos_long] != short_str[pos_short])
break;
pos_long++;
pos_short++;
}
if (pos_short == short_str.length())
cout << "true" << endl;
else
cout << "false" << endl;
}
int main()
{
string strOne = "ABCDAK";
string strTwo = "A";
string long_str = strOne;
string short_str = strTwo;
// 对字符串进行计数排序
CounterSort(strOne, long_str);
CounterSort(strTwo, short_str);
// 比较排序好的字符串
Compare(long_str, short_str);
return 0;
}
思路三:哈希表方法
当我们看到数组每个参数的取值范围固定的时候,应该考虑一下能否应用哈希表去解决问题。
常规思路是:遍历长数组,然后再对应的哈希表中赋值,表示存在此数据;然后遍历短数组,通过哈希表映射,判断是否已经在哈希表中,如果没有就退出,判断结束,否则就继续遍历,直到遍历完成。
但是,还能对上面的进行优化,上面的时间复杂度一定是O(n+m),但如果我们先遍历短的数组O(m),并记下不重复数据的个数,然后遍历长的数组,如果不在,就继续遍历;如果在,就清除标记,计数值num减一。
算法如下:
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 扫描结束,退出循环。
代码如下:
//Hash方法,按照常规先扫描长的字符串序列,但扫描短的效率更高
void CompareHash(char *Lbuf,char *Sbuf)
{
int hash[26] = {0};
int Lsize = strlen(Lbuf);
int Ssize = strlen(Sbuf);
int num = 0; //计算短字符串中的不重复数据的个数,便于遍历长字符串的时候,减少不必要的循环
for(int i = 0;i < Ssize;i++){
int index = Sbuf[i] - 'A';
if(hash[index] == 0){
hash[index] = 1;
num++;
}
}
for(int i = 0;i < Lsize;i++){
int index = Lbuf[i] - 'A';
if(hash[index]){ //当在数组中存在的时候,减少数据的个数
hash[index] = 0; //但是,相应的hash值应该清零,因为num代表的是不重复数据,如果不清零,会重复减小num,造成逻辑错误
num--;
if(num == 0)
break;
}
}
if(num)
printf("false!");
else
printf("true!");
}
注意:当我们应用巧方法去做的时候,也会造成潜在的危险,可能遗漏一些判断条件,一定要考虑全面。比如该代码中的num值和对hash数组的清零。
思路四:利用素数
我们换一种角度思考本问题:
假设有一个仅由字母组成字串,让每个字母与一个素数对应,从2开始,往后类推,A对应2,B对应3,C对应5,......。遍历第一个字串,把每个字母对应素数相乘。最终会得到一个整数。
利用上面字母和素数的对应关系,对应第二个字符串中的字母,然后轮询,用每个字母对应的素数除前面得到的整数。如果结果有余数,说明结果为false。如果整个过程中没有余数,则说明第二个字符串是第一个的子集了(判断是不是真子集,可以比较两个字符串对应的素数乘积,若相等则不是真子集)。
思路总结如下:
- 按照从小到大的顺序,用26个素数分别与字符'A'到'Z'一一对应。
- 遍历长字符串,求得每个字符对应素数的乘积。
- 遍历短字符串,判断乘积能否被短字符串中的字符对应的素数整除。
- 输出结果。
如前所述,算法的时间复杂度为O(m+n)的最好的情况为O(n)(遍历短的字符串的第一个数,与长字符串素数的乘积相除,即出现余数,便可退出程序,返回false),n为长字串的长度,空间复杂度为O(1)。
//此方法只有理论意义,因为整数乘积很大,有溢出风险
bool StringContain(string &a,string &b)
{
const int p[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 f = 1;
for (int i = 0; i < a.length(); ++i)
{
int x = p[a[i] - 'A'];
if (f % x)<span style="white-space:pre"> </span>//考虑了重复的数据
{
f *= x;
}
}
for (int i = 0; i < b.length(); ++i)
{
int x = p[b[i] - 'A'];
if (f % x)
{
return false;
}
}
return true;
}
此种素数相乘的方法看似完美,但缺点是素数相乘的结果容易导致整数溢出。
思路五:利用位来表示
利用位来表示hash表,降低了空间复杂度!目前已经碰到过几个,要学会这种方法。
事实上,可以对短字符串进行轮询,把其中的每个字母都放入一个Hashtable里(始终设m为短字符串的长度,那么此项操作成本是O(m)次操作)。然后轮询长字符串,在Hashtable里查询短字符串的每个字符,看能否找到。如果找不到,说明没有匹配成功。
再进一步,我们可以对字符串A,用位运算(26bit整数表示)计算出一个“签名”,再用B中的字符到A里面进行查找。
// “最好的方法”,时间复杂度O(n + m),空间复杂度O(1)
bool StringContain(string &a,string &b)
{
int hash = 0;
for (int i = 0; i < a.length(); ++i)
{
hash |= (1 << (a[i] - 'A'));
}
for (int i = 0; i < b.length(); ++i)
{
if ((hash & (1 << (b[i] - 'A'))) == 0)
{
return false;
}
}
return true;
}
扩展:
如果两个字符串的字符一样,但是顺序不一样,被认为是兄弟字符串,比如bad和adb即为兄弟字符串,现提供一个字符串,如何在字典中迅速找到它的兄弟字符串,请描述数据结构和查询过程。