【July程序员编程艺术】之字符串是否包含问题

题目描述：

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

比如，如果是下面两个字符串：

String 1: ABCDEFGHLMNOPQRS

String 2: DCGSRQPO

答案是true，所有在string2里的字母string1也都有。

如果是下面两个字符串：

String 1: ABCDEFGHLMNOPQRS

String 2: DCGSRQPZ

答案是false，因为第二个字符串里的Z字母不在第一个字符串里

我的解题思路：

1.最笨的方法

任何好的方法都是将笨方法不断改进得到，因此拿到这个题目第一反应就是笨方法。对于String 2中的每一个字符，都拿到String 1中挨个找一下。这样写出来的程序是两层遍历，假设长字符串长度为n,短字符串长度为m，那么这种算法的时间复杂度是O(mn)。肯定是不好的。

2.初步改进的思路

思考如何在笨方法的基础上进行改进。笨方法中string1中的字符被重复遍历了m次，这无疑是冗余和可以优化的地方。要想减少遍历string1的次数，那么连续的两次遍历之间需要有联系才行。于是就想到了能不能先将字符串排个序，这样第一次遍历的结果就可以为第二次遍历提供帮助了。说到排序，最容易想到的自然就是快速排序算法，即July博客中所讲到的方法1.2。编写程序如下：

#include "quick_sort.h"
#include <iostream>
#include <string>
using namespace std;
template <class T>
//int src[]={72,6,57,88,60,42,83,73,48,85};
int partition(T * src,T * end)
{
T * sp=src; //起始位置指针
T * ep=end; //结束位置指针
T tmp;
T * cp=src;
while(ep>sp)
{
while((*ep>=*cp)&&(ep>cp))
ep--;
if(ep<=cp)
break;
swap<T>(cp,ep);
cp=ep;
while((*sp<=*cp)&&(sp<cp))
sp++;
if(sp>=cp)
break;
swap<T>(cp,sp);
cp=sp;

}
int res = cp-src;
return res;
}

template <class T>
void swap(T * a,T * b )
{
T tmp;
tmp=*a;
*a=*b;
*b=tmp;
}

template <class T>
void quick_sort(T *src,T * end)
{
if(end>src)
{
int q = partition(src,end);
quick_sort(src,src+q-1);
quick_sort(src+q+1,end);
}
}

int compare(string & l_str,string & s_str)
{
char * lp,*sp,*l_end,*s_end;
lp=&(l_str[0]);
sp=&(s_str[0]);
l_end=lp+l_str.length()-1;
s_end=sp+s_str.length()-1;
while((lp<=l_end)&&(sp<=s_end))
{
if(*lp<*sp)
lp++;
else
{
if(*lp=*sp)
{
lp++;
sp++;
}
else
return 0;
}
}
if(sp<=s_end)
return 0;
else
return 1;

}
void main()
{
string l_str("ABCDEFGHLMNOPQRS");
string s_str("DCGSRQPOV");
//string l_str("ABCDE");
//string s_str("BE");
int result = 0;
int l_len = l_str.length();
int s_len = s_str.length();
char * l_st,* l_end,* s_st,* s_end;
l_st=&(l_str[0]);
l_end=&(l_str[0])+l_len-1;

s_st=&(s_str[0]);
s_end=&(s_str[0])+s_len-1;

quick_sort(l_st,l_end);
quick_sort(s_st,s_end);
cout << "long string" << l_str << endl;
cout << "short string" << s_str << endl;

result=compare(l_str,s_str);
cout<<"ok"<< result<<endl;
}

最近程序练得少，写快速排序程序时候花了一番功夫。自己写一篇快排程序之后感觉对快排理解更加深刻了一些。之前对于partition的实现过程不是太理解，现在有了进一步的理解如下：

对于数组[3,1,5,2,7,8]，假定取3作为基准元素进行划分，那么划分的目标就是使3的左边都是小于的，3的右边都是大于3的。刚开始3处于0位置，所以左边没有元素，那么就要想办法使得右边的元素都大于3.要使得右边的元素都大于3，那么最右边的肯定需要大于3，于是就对8进行判断，ok,然后就是7，ok,然后是2。2就不符合条件了，所以把3和2对调，得到2,1,5,3,7,8.现在3的右边元素都ok了，但是左边的还无法保证，所以再从最左边的2开始.重复这样的过程，就可以实现partition。partition算法的特点是交替着从左右两侧进行判断。

看到算法1.3的时候，就想到了利用字符的特性来进一步改进算法。假设都是大写字符，那么一共就26个，所以建立长度为26的缓存数组，遍历一次长字符串就可以知道长字符串包含哪些字符。之后对于短字符串中的每个字符，就不需要再去遍历长字符了，直接根据字符减去’A’得到下标就可以知道长字符串中有没有该字符。这种做法是很巧妙的，很好的利用了字符的特性，时间复杂度也优化到了O(m+n)，空间复杂度是O(1)。2.1 2.2都是这个思路。

第三种素数的方法就比较新奇了。

博客最后给了一个扩展题。a和b两个字符串，求b串包含a串的最小长度。包含指的就是b的字串包含a中每个字符。

简单想了一下，建立26个字符的缓存数组可以较好地解决问题。当b中包含重复的字符串的时候，则需要进行一些判断方可。准备有空把这个题目的程序也写写。以后遇到字符串比较的算法题，都可以往26个字符缓存数组的思路上去想。