程序员面试题精选100题(46)－对称子字符串的最大长度
题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。
分析：可能很多人都写过判断一个字符串是不是对称的函数，这个题目可以看成是该函数的加强版。
引子：判断字符串是否对称
要判断一个字符串是不是对称的，不是一件很难的事情。我们可以先得到字符串首尾两个字符，判断是不是相等。如果不相等，那该字符串肯定不是对称的。否则我们接着判断里面的两个字符是不是相等，以此类推。基于这个思路，我们不难写出如下代码：
// Whether a string between pBegin and pEnd is symmetrical?
bool IsSymmetrical(char* pBegin, char* pEnd)
{
if(pBegin == NULL || pEnd == NULL || pBegin > pEnd)
return false;
while(pBegin < pEnd)
{
if(*pBegin != *pEnd)
return false;
pBegin++;
pEnd --;
}
return true;
}
要判断一个字符串pString是不是对称的，我们只需要调用IsSymmetrical(pString, &pString[strlen(pString) – 1])就可以了。
解法一：O（n3）的算法
现在我们试着来得到对称子字符串的最大长度。最直观的做法就是得到输入字符串的所有子字符串，并逐个判断是不是对称的。如果一个子字符串是对称的，我们就得到它的长度。这样经过比较，就能得到最长的对称子字符串的长度了。于是，我们可以写出如下代码：
// Get the longest length of its all symmetrical substrings
// Time needed is O(T^3)
int GetLongestSymmetricalLength_1(char* pString)
{
if(pString == NULL)
return 0;
int symmeticalLength = 1;
char* pFirst = pString;
int length = strlen(pString);
while(pFirst < &pString[length - 1])
{
char* pLast = pFirst + 1;
while(pLast <= &pString[length - 1])
{
if(IsSymmetrical(pFirst, pLast))
{
int newLength = pLast - pFirst + 1;
if(newLength > symmeticalLength)
symmeticalLength = newLength;
}
pLast++;
}
pFirst++;
}
return symmeticalLength;
}
我们来分析一下上述方法的时间效率。由于我们需要两重while循环，每重循环需要O（n）的时间。另外，我们在循环中调用了IsSymmetrical，每次调用也需要O（n）的时间。因此整个函数的时间效率是O（n3）。
通常O（n3）不会是一个高效的算法。如果我们仔细分析上述方法的比较过程，我们就能发现其中有很多重复的比较。假设我们需要判断一个子字符串具有aAa的形式（A是aAa的子字符串，可能含有多个字符）。我们先把pFirst指向最前面的字符a，把pLast指向最后面的字符a，由于两个字符相同，我们在IsSymtical函数内部向后移动pFirst，向前移动pLast，以判断A是不是对称的。接下来若干步骤之后，由于A也是输入字符串的一个子字符串，我们需要再一次判断它是不是对称的。也就是说，我们重复多次地在判断A是不是对称的。
造成上述重复比较的根源在于IsSymmetrical的比较是从外向里进行的。在判断aAa是不是对称的时候，我们不知道A是不是对称的，因此需要花费O（n）的时间来判断。下次我们判断A是不是对称的时候，我们仍然需要O（n）的时间。
测试代码为:
#include "stdafx.h"
#include <iostream>
using namespace std;
/************************************************
* 判断一个字符串是否是对称的
*************************************************/
bool IsSymmetricalString(char* pstart,char* pend)
{
if (pstart==NULL || pend==NULL || pstart>pend)
{
return false;
}
while (pstart<pend)
{
if (*pstart!=*pend)
{
return false;
}
pstart++;
pend--;
}
return true;
}
/*************************************************
* 求最大对称子串的长度
**************************************************/
int MaxSymmetricalSubstringLenth(char *pstring)
{
if (pstring==NULL)
{
return 0;
}
int maxLength=1;
int length=strlen(pstring);
char* pstart=pstring;
while (pstart<&pstring[length-1])
{
char* psecond=pstart+1;
while (psecond<=&pstring[length-1])
{
if (IsSymmetricalString(pstart,psecond))
{
int tempLength=psecond-pstart+1;
if (tempLength>maxLength)
{
maxLength=tempLength;
}
}
psecond++;
}
pstart++;
}
return maxLength;
}
int _tmain(int argc, _TCHAR* argv[])
{
cout<<"Please Enter Your String(the length must <1000 ):"<<endl;
char* yourstring = new char[1000];
cin>>yourstring;
cout<<"The Max Symmetrical SubString Length in Your String is:"<<endl;
cout<<MaxSymmetricalSubstringLenth(yourstring)<<endl;
system("pause");
return 0;
}
解法二：O（n2）的算法
如果我们换一种思路，我们从里向外来判断。也就是我们先判断子字符串A是不是对称的。如果A不是对称的，那么向该子字符串两端各延长一个字符得到的字符串肯定不是对称的。如果A对称，那么我们只需要判断A两端延长的一个字符是不是相等的，如果相等，则延长后的字符串是对称的。因此在知道A是否对称之后，只需要O（1）的时间就能知道aAa是不是对称的。
我们可以根据从里向外比较的思路写出如下代码：
// Get the longest length of its all symmetrical substrings
// Time needed is O(T^2)
int GetLongestSymmetricalLength_2(char* pString)
{
if(pString == NULL)
return 0;
int symmeticalLength = 1;
char* pChar = pString;
while(*pChar != '\0')
{
// Substrings with odd length
char* pFirst = pChar - 1;
char* pLast = pChar + 1;
while(pFirst >= pString && *pLast != '\0' && *pFirst == *pLast)
{
pFirst--;
pLast++;
}
int newLength = pLast - pFirst - 1;
if(newLength > symmeticalLength)
symmeticalLength = newLength;
// Substrings with even length
pFirst = pChar;
pLast = pChar + 1;
while(pFirst >= pString && *pLast != '\0' && *pFirst == *pLast)
{
pFirst--;
pLast++;
}
newLength = pLast - pFirst - 1;
if(newLength > symmeticalLength)
symmeticalLength = newLength;
pChar++;
}
return symmeticalLength;
}
由于子字符串的长度可能是奇数也可能是偶数。长度是奇数的字符串是从只有一个字符的中心向两端延长出来，而长度为偶数的字符串是从一个有两个字符的中心向两端延长出来。因此我们的代码要把这种情况都考虑进去。
在上述代码中，我们从字符串的每个字符串两端开始延长，如果当前的子字符串是对称的，再判断延长之后的字符串是不是对称的。由于总共有O（n）个字符，每个字符可能延长O（n）次，每次延长时只需要O（1）就能判断出是不是对称的，因此整个函数的时间效率是O（n2）。
测试代码:
// MaxSymmetricalSubstringLenth.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<iostream>
#include<string>
using namespace std;
/*********************************************************************
* 计算字符串最大对称子串的长度
*********************************************************************/
int GetLongestSymmetricalLength_2(char* pString)
{
if(pString == NULL)
return 0;
int symmeticalLength = 1;
char* pChar = pString;
while(*pChar != '\0')
{
// Substrings with odd length(奇数)
char* pFirst = pChar - 1;
char* pLast = pChar + 1;
while(*pLast != '\0' && *pFirst == *pLast)
{
pFirst--;
pLast++;
}
int newLength = pLast - pFirst - 1;
if(newLength > symmeticalLength)
symmeticalLength = newLength;
// Substrings with even length(偶数)
pFirst = pChar;
pLast = pChar + 1;
while( *pLast != '\0' && *pFirst == *pLast)
{
pFirst--;
pLast++;
}
newLength = pLast - pFirst - 1;
if(newLength > symmeticalLength)
symmeticalLength = newLength;
pChar++;
}
return symmeticalLength;
}
int main()
{
cout<<"Please Enter Your String:"<<endl;
char *yourstring = new char[1000];
cin>>yourstring;
cout<<"The Max Symmetrical SubString Length is:"<<endl;
cout<<GetLongestSymmetricalLength_2(yourstring)<<endl;
delete[] yourstring;
system("pause");
return 0;
}
参考来源: http://zhedahht.blog.163.com/blog/static/25411174201063105120425/
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
