字符串问题

摘自http://www.epubit.com.cn/book/onlinechapter/33918

第1章 字符串

编程之法：面试和算法心得

与字符串相关的问题在各大互联网公司的笔试和面试中出现的频率极高。例如，网上广为流传的一道单词翻转题：输入“I am a student.”，要求输出“student. a am I”。

本章重点介绍6个典型的字符串问题，分别是字符串的旋转、字符串的包含、字符串的全排列、字符串转换成整数、回文判断、最长回文子串。这6个问题中，除了“将字符串转换成整数”这个问题需要特别注意细节之外，其他5个问题都有多种思路和多种解法，比如先从蛮力解法入手，然后考虑是否能逐步优化。

读完本章后读者会发现，好的思路都是在充分考虑到问题本身的特征的前提下，或巧用合适的数据结构，或选择合适的算法降低时间复杂度，或选用效率更高的算法。

1.1　字符串的旋转

题目描述

给定一个字符串，要求将字符串前面的若干个字符移到字符串的尾部。例如，将字符串"abcdef"的前3个字符'a'、'b'和'c'移到字符串的尾部，那么原字符串将变成"defabc"。请写一个函数实现此功能。

分析与解法

解法一：蛮力移位

初看此题，可能最先想到的方法是将需要移动的字符一个一个地移到字符串的尾部。

如果定义指向该字符串的一个指针s，然后设该字符串的长度为n，那么，可以先编写一个函数LeftShiftOne (char* s, int n)，以完成将一个字符移到字符串尾部的功能：

void LeftShiftOne(char* s, int n)
{
 　　// 保存第一个字符
 　　char t = s[0];
 　　for (int i = 1; i < n; i++)
 　　{
 　　　　s[i - 1] = s[i];
 　　}
 　　s[n - 1] = t;
}

然后再调用m次LeftShiftOne函数，使得字符串开头的m个字符移到字符串的尾部：

void LeftRotateString(char* s, int n, int m)
{
 　　while (m--)
 　　{
 　　　　LeftShiftOne(s, n);
 　　}
}

这样就完成了将若干个字符移到字符串尾部的要求。

下面来分析一下这种方法的时间复杂度和空间复杂度。针对长度为n的字符串来说，假设需要移动m个字符到字符串的尾部，那么总共需要m×n次操作。同时设立一个变量保存第一个字符。因此，时间复杂度为O (mn)，空间复杂度为O (1)。

有没有更好的办法来降低时间复杂度呢？

解法二：三步反转

对于这个问题，换一个角度思考一下。既然题目要求将字符串前面的那部分原封不动地移到字符串的尾部，那么是否可以把需要移动的部分跟不需要移动的部分分开处理呢？例如，可以先将一个字符串分割成两个部分，然后将这两个部分的字符串分别反转，最后再对整个字符串进行整体反转，即可解决字符串旋转的问题。

拿题目中的例子来说，给定字符串"abcdef"，若要将"def"移动到"abc"的前面，只需要按照下述3个步骤操作即可。

（1）将原字符串分为X和Y两个部分，其中X为"abc"，Y为"def"。

（2）将X的所有字符反转，即相当于反转"abc"得到"cba"；再将Y的所有字符也反转，即相当于反转"def"得到"fed"。

（3）最后，将上述步骤得到的结果再给予整体反转，即整体反转"cbafed"得到"defabc"，这样，就实现了字符串的反转。

参考代码如下：

void ReverseString(char* s, int from, int to)
{
 　　while (from < to)
 　　{
 　　　　char t = s[from];
 　　　　s[from++] = s[to];
 　　　　s[to--] = t;
 　　}
}
void LeftRotateString(char* s, int n, int m)
{
 　　// 若要左移动大于n位，那么与%n是等价的
 　　m %= n;
 　　ReverseString(s, 0, m - 1);
 　　ReverseString(s, m, n - 1);
 　　ReverseString(s, 0, n - 1);
}

这种把字符串先分为两个部分，各自反转，最后整体反转的方法，俗称“三步反转”法，其时间复杂度为O(n)，空间复杂度为O(1)。

举一反三

单词翻转

输入一个英文句子，翻转句子中单词的顺序。要求单词内字符的顺序不变，句子中单词以空格符隔开。为简单起见，标点符号和普通字母一样处理。例如，若输入“I am a student.”，则输出“student. a am I”。

1.2　字符串的包含

题目描述

给定一长字符串a和一短字符串b。请问，如何最快地判断出短字符串b中的所有字符是否都在长字符串a中？请编写函数boolStringContain(string &a, string &b)实现此功能。

为简单起见，假设输入的字符串只包含大写英文字母。下面举几个例子。

• 如果字符串a是"ABCD"，字符串b是"BAD"，答案是true，因为字符串b中的字母都在字符串a中，或者说b是a的真子集。
• 如果字符串a是"ABCD"，字符串b是"BCE"，答案是false，因为字符串b中的字母E不在字符串a中。
• 如果字符串a是"ABCD"，字符串b是"AA"，答案是true，因为字符串b中的字母A包含在字符串a中。

分析与解法

此题初看似乎很简单，但要高效地实现并不轻松。而且，如果面试官步步紧逼，一个一个否决你想到的方法，要求你给出更快、更好的方案，恐怕就要费不少脑筋了。

解法一：蛮力轮询

判断短字符串b中的字符是否都在长字符串a中，最直观也是最简单的思路则是：轮询短字符串b中的每一个字符，逐个与长字符串a中的每个字符进行比较，看是否都在字符串a中。

参考代码如下：

bool StringContain(string &a, string &b)
{
 　　for (int i = 0; i < b.length(); ++i)
 　　{
 　　　　int j;
 　　　　for (j = 0; (j < a.length()) && (a[j] != b[i]); ++j)
 　　　　　　;
 　　　　if (j >= a.length())
 　　　　{
 　　　　　　return false;
 　　　　}
 　　}
 　　return true;
}

如果n是长字符串a的长度，m是短字符串b的长度，那么此算法需要O(nm)次比较。显然，如果n和m很大，时间开销太大，需要寻找更好的办法。

解法二：排序后轮询

如果允许排序，可以考虑先排序后轮询。例如，可先对这两个字符串中的字母进行排序，然后再对两个字符串依次轮询。

常规情况下，两个字符串的排序需要O(mlogm)+O(nlogn)次操作，之后的线性扫描需要O(m+n)次操作。关于排序方法，可以采用最常用的快速排序。

参考代码如下：

bool StringContain(string &a, string &b)
{
 　　sort(a.begin(), a.end());
 　　sort(b.begin(), b.end());
 　　for (int pa = 0, pb = 0; pb < b.length();)
 　　{
 　　　　while ((pa < a.length()) && (a[pa] < b[pb]))
 　　　　{
 　　　　　　++pa;
 　　　　}
 　　　　if ((pa >= a.length()) || (a[pa] > b[pb]))
 　　　　{
 　　　　　　return false;
 　　　　}
 　　　　++pb;
 　　}
 　　return true;
}

解法三：素数相乘

有没有比排序后轮询更好的方法呢？

首先，让长字符串a中的每个字母与一个素数对应，如A对应2，B对应3，C对应5，……，依次类推。再遍历长字符串a，把a中的每个字母对应的素数相乘，得到一个整数。然后，让短字符串b中的字母也对应相应的素数，再用b中的每个字母对应的素数除上面得到的整数。如果结果有余数，说明结果为false，当即退出程序；如果整个过程中没有余数，则说明短字符串b是长字符串a的子集。

具体思路总结如下。

（1）按照从小到大的顺序，用26个素数分别代替长字符串a中的所有字母。

（2）遍历长字符串a，求得a中的所有字母对应的素数的乘积。

（3）遍历短字符串b，判断上一步得到的乘积能否被b中的字母对应的素数整除。

（4）输出结果。

上述算法的时间复杂度为O(m+n)。当然，最好情况下的时间复杂度为O(n)，即在遍历短字符串b的第一个字母，与长字符串a中所有字符所对应的素数的乘积相除时，当即出现余数，便直接退出程序，返回false。

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)
 　　　　{
 　　　　　　f *= x;
 　　　　}
 　　}
 　　for (int i = 0; i < b.length(); ++i)
 　　{
 　　　　int x = p[b[i] - 'A'];
 　　　　if (f % x)
 　　　　{
 　　　　　　return false;
 　　　　}
 　　}
 　　return true;
}

这种素数相乘的方法看似可行，实则不可行，因为素数相乘的结果会很大，从而导致整数溢出（前16个字母对应的素数相乘便会超出long long类型所能表示的最大整数范围）。

解法四：位运算法

如果面试官继续追问，到底有没有更好的办法呢？或许你绞尽脑汁能想到计数排序。但除了计数排序还有别的办法吗？

事实上，可以先把长字符串a中的所有字符都放入一个散列表（hash table）中，然后轮询短字符串b，看b中的每个字符是否都在散列表里，如果都在，说明长字符串a包含短字符串b；否则，说明不包含。

再进一步，可以用位运算（26位整数表示）为长字符串a计算出一个“签名”，再逐一将短字符串b中的字符放到a中进行查找。

参考代码如下：

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;
}

这个位运算方法的实质是用一个整数代替了散列表，它的空间复杂度为O(1)，时间复杂度为O(n+m)。至此，算是比较完美地解决了这个字符串包含的问题。

但是，这样真的完美了吗？请读者继续思考。

举一反三

变位词

如果两个字符串中的字符一样，出现次数也一样，只是出现的顺序不一样，则认为这两个字符串是兄弟字符串。例如，"bad"和"adb"即为兄弟字符串。现提供一个字符串，请问如何在字典中迅速找到它的兄弟字符串？

1.3　字符串的全排列

题目描述

输入一个字符串，打印出该字符串中字符的所有排列。例如，输入字符串"abc"，则输出由字符'a'、'b'、'c'所能排列出来的所有字符串"abc"、"acb"、"bac"、"bca"、"cab"和"cba"。

分析与解法

解法一：递归实现

从字符串中选出一个字符作为排列的第一个字符，然后对剩余的字符进行全排列。如此递归处理，从而得到所有字符的全排列。以对字符串"abc"进行全排列为例，可以按下述步骤执行。

• 将a固定在第一位，求后面bc的排列，得到："abc"和"acb"。
• 将b固定在第一位，求后面ac的排列，得到："bac"和"bca"。
• 将c固定在第一位，求后面ba的排列，得到："cba"和"cab"。

参考代码如下：

void CalcAllPermutation(char* perm, int from, int to)
{
 　　if (to <= 1)
 　　{
 　　　　return;
 　　}
 　　if (from == to)
 　　{
 　　　　for (int i = 0; i <= to; i++)
 　　　　{
 　　　　　　cout << perm[i];
 　　　　}
 　　　　cout << endl;
 　　}
 　　else
 　　{
 　　　　for (int j = from; j <= to; j++)
 　　　　{
 　　　　　　swap(perm[j], perm[from]); {![本书中使用的swap是STL库函数，声明为void swap（int& a，int& b）；。]}
 　　　　　　CalcAllPermutation(perm, from + 1, to);
 　　　　　　swap(perm[j], perm[from]);
 　　　　}
 　　}
}

解法二：字典序排列

根据维基百科的定义：给定两个偏序集A和B，(a, b)和(a′, b′)属于笛卡儿集A×B，则字典序定义为(a, b)≤(a′, b′)当且仅当a < a′或a = a′且b≤b′。

根据上述字典序的定义可知，如果给定两个字符串，从起点开始将它们对应的字符逐个进行比较，则先出现较小字符的那个字符串的字典序小；如果字符一直相等，则较短的那个字符串的字典序小。例如，"abc"、"abcd"、"abde"、"afab"这几个字符串按照字典序从小到大的顺序排列则是"abc"<"abcd" <"abde"<"afab"。

那么，有没有执行的起点、终点、过程如下的算法呢？

• 算法起点：字典序最小的排列1～n，如"12345"。
• 算法终点：字典序最大的排列n～1，如"54321"。
• 算法的执行过程：从当前排列生成字典序刚好比它大的下一个排列。

答案是肯定的，这就是C++ 标准库（STL）中的next_permutation函数实现的算法。在了解next_permutation函数是怎么实现的之前，先来分析一下“下一个排列”的性质。

假定现有字符串AxB，它的下一个排列是AyB′，其中A、B和B′是字符串（可能为空），x和y是字符，前缀相同，都是A，且一定有y>x。那么，为了使下一个排列字典顺序尽可能小，必有：A尽可能长，而y尽可能小，最后B′里的字符按由小到大递增排列。现在的问题是，如何确定x和y呢？

来看一个例子。例如，要找21543的下一个排列，则可以从左至右逐个扫描每个数，看哪个能增大（即如果一个数的右面有比它大的数存在，那么这个数就能增大），可以看到最后一个能增大的数是：x=1。而1应该增大到多少呢？1能增大到它右面比它大的那一系列数中最小的那个数，即y=3，故此时21543的下一个排列应该变为23xxx，显然xxx（对应之前的B′）应由小到大排列，于是最终找到比21543大但字典顺序尽量小的23145（找到的23145刚好比21543大）。

先来定义“升序”，即相邻两个位置ai<ai+1，ai称作该升序的首位。

由上述的例子可以得出next_permutation算法的具体步骤（二找、一交换、一翻转）如下。

（1）找到排列中最后（最右）一个升序的首位位置i，x = ai。

（2）找到排列中第i位右边最后一个比ai大的位置j，y = aj。

（3）交换x和y。

（4）把第i+1位到最后的部分翻转（执行此步骤前，因为第i位是最后一个升序的位置，所以从i+1到n一定是降序排列的，而执行此步骤后，从i+1到n变成升序排列）。

还是拿上面的21543举例，那么，应用next_permutation算法的过程如下。

• x = 1。
• y = 3。
• 1和3交换，得23541。
• 翻转541，得23145。

23145即为所求的21543的下一个排列。

参考代码如下：

bool CalcAllPermutation(char* perm, int num){
 　　int i;

 　　// 步骤1：找到排列中最后（最右）一个升序的首位位置i，x = ai
 　　for (i = num - 2; (i >= 0) && (perm[i] >= perm[i + 1]); --i){
 　　　　;
 　　}
 　　// 已经找到所有排列
 　　if (i < 0){
 　　　　return false;
 　　}

 　　int k;
 　　// 步骤2：找到排列中第i位右边最后一个比ai 大的位置j，y = aj
 　　for (k = num - 1; (k > i) && (perm[k] <= perm[i]); --k){
 　　　　;
 　　}

 　　// 步骤3：交换x和y
 　　swap(perm[i], perm[k]);
 　　// 步骤4：把第i+ 1位到最后的部分翻转
 　　reverse(perm + i + 1, perm + num);
 　　return true;
}

然后在主函数里循环判断和调用CalcAllPermutation函数即可按照字典顺序输出所有排列。

由于全排列总共有n!种排列情况，所以不论解法一中的递归方法，还是解法二中的字典序排列方法，时间复杂度都为O(n!)。

举一反三

字典序的所有排列

已知字符串中的字符是互不相同的，现在把它们任意排列（例如，若已知字符串是"ab"，则任意排列是"aa"、"ab"、"ba"和"bb"），编程按照字典序输出所有的组合。

点评：这并非简单的全排列问题（跟全排列的形式不同，"abc"全排列的话，只有6个不同的输出）。本题可用递归的思想，设置一个变量表示已输出的个数，然后当个数达到字符串长度时，就输出。

字符的所有组合

如果不是求字符串中所有字符的所有排列，而是求字符的所有组合，应该怎么办呢？当输入的字符串中含有相同的字符时，相同的字符交换位置是不同的排列，但却是同一个组合。举个例子，如果输入"abc"，它的组合有"a"、"b"、"c"、"ab"、"ac"、"bc"和"abc"。

序列的打印

写一个程序，打印出如下序列：

(a),(b),(c),(d),(e)........(z)
(a,b),(a,c),(a,d),(a,e)......(a,z),(b,c),(b,d).....(b,z),(c,d).....(y,z)
(a,b,c),(a,b,d)....(a,b,z),(a,c,d)....(x,y,z)
....
(a,b,c,d,.....x,y,z)

1.4　字符串转换成整数

题目描述

输入一个由数字组成的字符串，请把它转换成整数并输出。例如，输入字符串"123"，输出整数123。

函数原型为int StrToInt(const char *str)，请实现字符串转换成整数的功能，不能使用库函数atoi。

分析与解法

本题实际上考查的是把字符串转换成整数的问题，或者说要你自行实现atoi函数。那么，如何把由数字组成的字符串正确地转换成整数呢？

下面以"123"为例，说明这一转换过程。

（1）当扫描到字符串的第一个字符'1'时，因为这是第一位，所以得到整数1。

（2）当扫描到第二个字符'2'时，因为之前已有一个1（相当于10），所以得到的整数为110+2=12。

（3）继续扫描到第三个字符'3'，因为'3'的前面已经有了12（相当于120），所以最终得到的数为1210+3=123。

因此，此题的基本思路便是：从左至右扫描字符串中的每个字符，把之前扫描得到的数字乘以10，再加上当前字符表示的数字。

思路有了，代码可以编写如下：

int StrToInt(const char *str)
{
 　　int n = 0;
 　　while (*str != 0)
 　　{
 　　　　int c = *str - '0';
 　　　　n = n * 10 + c;
 　　　　++str;
 　　}
 　　return n;
}

但是上述代码忽略了以下几个细节。

• 最好判断一下输入是否为空。
• 如果字符串的第一个字符是'−'号，最终得到的整数必为负整数。
• 输入的字符串中不能含有不是数字的字符。
• 输入的字符串不能太长，否则转换成整数后可能会导致整数溢出。

上述问题中的前三个问题都比较好处理，但最后一个溢出问题比较麻烦，所以重点看一下这个问题。

一般来说，当发生溢出时，取最大或最小的int型值，即大于正整数能表示的范围时返回 MAX_INT（2147483647），小于负整数能表示的范围时返回 MIN_INT（−2147483648）。

编写代码之前，先来设置一些变量。

• sign用来处理数的正负，当sign > 0时为正，当sign < 0时为负。
• n存放最终转换后的结果。
• c表示当前数字。

而后，你可能会编写如下代码来处理溢出问题：

// 当发生正溢出时，返回MAX_INT
if ((sign == '+') && (c > MAX_INT - n * 10))
{
 　　n = MAX_INT;
 　　break;
}
// 当发生负溢出时，返回MIN_INT
else if ((sign == '-') && (c - 1 > MAX_INT - n * 10))
{
 　　n = MIN_INT;
 　　break;
}

但当上述代码转换"10522545459"时会出错，因为正常的话理应得到MAX_INT（即2147483647），可上述程序的运行结果却是1932610867。

为什么呢？因为给定的字符串是"10522545459"，MAX_INT是2147483647，这样MAX_INT<n×10（即1052254545×10），即MAX_INT–n×10小于0，所以当扫描到最后一个字符'9'的时候，执行下面这行代码已无意义（程序已经出错）：

c > MAX_INT - n * 10

针对这种由于输入了一个很长的字符串，导致转换之后出现了大于能够表示的最大整数的数而引起的溢出情况，有两种处理方式可以选择。一种比较取巧的方式是把转换后返回的值n定义成long long类型，即long long n，另一种则是只比较n和MAX_INT/10的大小，即：

• 若n>MAX_INT/10，那么说明最后一步转换时，n×10必定大于MAX_INT，所以在得知n > MAX_INT/10时，当即返回MAX_INT；
• 若n == MAX_INT/10时，那么比较最后一个数字c跟MAX_INT%10的大小,即如果n == MAX_INT/10且c > MAX_INT%10，则照样返回MAX_INT。

对于第一种方式，虽然把n定义为长整型，但最后返回时系统会自动转换成整型。所以，接下来主要来看第二种处理方式。

对于第二种方式，先举两个例子说明一下。

（1）如果要转换的字符串是"2147483697"，那么当扫描到字符'9'时，判断出214748369> MAX_INT/10 = 2147483647/10=214748364（在C语言里，整数相除自动取整，舍弃小数），最终结果势必会溢出，故当即返回MAX_INT。

（2）如果要转换的字符串是"2147483648"，那么判断最后一个字符'8'所代表的数字8与MAX_INT % 10（等于7）的大小，前者大，依然返回MAX_INT。

一直以来的努力归根结底是为了更好地处理溢出，但上述第二种处理方式考虑到直接计算n ×10+c可能会大于MAX_INT，导致溢出，那么便两边同时除以10，只比较n和MAX_INT / 10的大小，从而巧妙地规避了计算n ×10这一乘法步骤（用计算除法MAX_INT/10代替），不能不说此法颇妙。

如此可以写出正确地处理溢出的代码，如下所示：

c = *str - '0';
if (sign > 0 && (n > MAX_INT / 10 || (n == MAX_INT / 10 && c > MAX_INT % 10)))
{
 　　n = MAX_INT;
 　　break;
}
else if (sign < 0 && (n >(unsigned)MIN_INT / 10 || (n == (unsigned)MIN_INT / 10 && c > (unsigned)MIN_INT % 10)))
{
 　　n = MIN_INT;
 　　break;
}

从而，字符串转换成整数的完整参考代码如下：

int StrToInt(const char* str)
{
 　　static const int MAX_INT = (int)((unsigned)~0 >> 1);
 　　static const int MIN_INT = -(int)((unsigned)~0 >> 1) - 1;
 　　unsigned int n = 0;

 　　// 判断输入是否为空
 　　if (str == 0)
 　　{
 　　　　return 0;
 　　}

 　　// 处理空格
 　　while (isspace(*str))
 　　　　++str;

 　　// 处理正负
 　　int sign = 1;
 　　if (*str == '+' || *str == '-')
 　　{
 　　　　if (*str == '-')
 　　　　　　sign = -1;
 　　　　++str;
 　　}

 　　// 确定是数字后才执行循环
 　　while (isdigit(*str))
 　　{
 　　　　// 处理溢出
 　　　　int c = *str - '0';
 　　　　if (sign > 0 && (n > MAX_INT / 10 || (n == MAX_INT / 10 && c > MAX_INT % 10)))
 　　　　{
 　　　　　　n = MAX_INT;
 　　　　　　break;
 　　　　}
 　　　　else if (sign < 0 && (n >(unsigned)MIN_INT / 10 || (n == (unsigned)MIN_INT / 10 &&
 　　　　　　　　 c > (unsigned)MIN_INT % 10)))
 　　　　{
 　　　　　　n = MIN_INT;
 　　　　　　break;
 　　　　}

 　　　　// 把之前得到的数字乘以10，再加上当前字符表示的数字
 　　　　n = n * 10 + c;
 　　　　++str;
 　　}
 　　return sign > 0 ? n : -n;
}

1.5　回文判断

题目描述

给定一个字符串，如何判断这个字符串是否是回文串？

分析与解法

所谓回文串，是指正读和反读都一样的字符串，如madam、我爱我。那么，如何通过程序判断一个字符串是否是回文串呢？

解法一：两头往中间扫

给定一个字符串，定义两个分别指向字符串的头和尾的指针，然后让这两个指针都往字符串的中间扫描，扫描的过程中，如果头和尾所指的字符至始至终都一样，则该字符串为回文串。

参考代码如下：

bool IsPalindrome(const char *s, int n)
{
 　　//非法输入
 　　if (s == NULL || n < 1)
 　　{
 　　　　return false;
 　　}
 　　const char* front, *back;

 　　// 初始化头指针和尾指针
 　　front = s;
 　　back = s + n - 1;

 　　while (front < back)
 　　{
 　　　　if (*front != *back)
 　　　　{
 　　　　　　return false;
 　　　　}
 　　　　++front;
 　　　　--back;
 　　}
 　　return true;
}

这个实现直白且效率不错，时间复杂度为O(n)，空间复杂度为O(1)。

解法二：从中间往两头扫

事实上，除了解法一中所说的用两个指针从两边向中间扫描，也可以先从字符串的中间开始向两头扫描，查看对应的字符是否依次相等。

参考代码如下：

bool IsPalindrome2(const char *s, int n)
{
 　　if (s == NULL || n < 1)
 　　{
 　　　　return false;
 　　}
 　　const char* first, *second;

 　　//m定位到字符串的中间位置      
 　　int m = ((n >> 1) - 1) >= 0 ? (n >> 1) - 1 : 0;
 　　first = s + m;
 　　second = s + n - 1 - m;

 　　while (first >= s)
 　　{
 　　　　if (*first != *second)
 　　　　{
 　　　　　　return false;
 　　　　}
 　　　　--first;
 　　　　++second;
 　　}
 　　return true;
}

这种方法的时间复杂度为O(n)，空间复杂度为O(1)。

举一反三

链表回文

判断一条单向链表是不是回文。

点评：易于想到的思路是采用两个指针从两边或者中间开始遍历，并判断对应字符是否相等。但由于单链表是单向的，如何实现双向遍历呢？比较常见的思路是采用经典的快慢指针方法，可先定位到链表的中间位置，再将链表的后半段逆置，然后用两个指针同时从链表头部和中间开始逐一向后遍历比较。

栈回文

判断一个栈是不是回文。

点评：根据栈的特性，可以将字符串全部压入栈，再依次将各个字符出栈，从而得到原字符串的逆置串，将逆置串中的各个字符分别和原字符串中的各个字符进行比较，如果完全一致，则为回文串。

1.6　最长回文子串

题目描述

给定一个字符串，求它的最长回文子串的长度。

分析与解法

最容易想到的办法是枚举其所有子串，逐一判断各个子串是否为回文串，如果为回文串，则记录并更新最长回文子串的长度。

解法一：中心扩展法

如何进行高效的判断呢？试想，如果一段字符串是回文串，那么以某个字符为中心的前缀和后缀必定是相同的。例如，以回文串"aba"为例，以b为中心，它的前缀和后缀都是 a。因此，我们可以枚举中心位置，然后再在该位置上扩展，记录并更新得到的最长回文串的长度。

参考代码如下：

int LongestPalindrome(const char *s, int n)
{
 　　int i, j, max, c;
 　　if (s == 0 || n < 1)
 　　{
 　　　　return 0;
 　　}
 　　max = 0;

 　　// i为回文的中心位置
 　　for (i = 0; i < n; ++i)
 　　{
 　　　　// 回文长度为奇数
 　　　　for (j = 0; (i - j >= 0) && (i + j < n); ++j)
 　　　　{
 　　　　　　if (s[i - j] != s[i + j])
 　　　　　　{
 　　　　　　　　break;
 　　　　　　}
 　　　　　　c = j * 2 + 1;
 　　　　}
 　　　　if (c > max)
 　　　　{
 　　　　　　max = c;
 　　　　}

 　　　　// 回文长度为偶数
 　　　　for (j = 0; (i - j >= 0) && (i + j + 1 < n); ++j)
 　　　　{
 　　　　　　if (s[i - j] != s[i + j + 1])
 　　　　　　{
 　　　　　　　　break;
 　　　　　　}
 　　　　　　c = j * 2 + 2;
 　　　　}
 　　　　if (c > max)
 　　　　{
 　　　　　　max = c;
 　　　　}
 　　}
 　　return max;
}

代码外层循环表示遍历回文子串中心为i的位置，内层的两个for循环分别处理的是以i为子串中心，回文子串长度为奇数和偶数的两种情况。简而言之，整个代码遍历中心位置i并以其为中心扩展，试图找出最长的回文子串。

解法二：Manacher算法

在上面的中心扩展法中，需要分开考虑字符串的长度是奇数还是偶数。是否有一种方法可以不用管长度是奇数还是偶数，而统一处理呢？例如，是否能把所有的情况全部转换为奇数处理？答案是肯定的。这就是Manacher算法。

Manacher算法首先通过在每个字符的两边都插入一个特殊的符号，将所有可能的奇数或偶数长度的回文子串都转换成奇数长度。例如，"abba"的两边插入字符#变成"#a#b#b#a#"，"aba"的两边插入字符#变成"#a#b#a#"。同时，为了进一步减少编码的复杂度和更好地处理越界问题，可以在字符串的开始加入另一个特殊字符，例如，在"#a#b#a#"的开始插入字符$变成"$#a#b#a#"。

以字符串"12212321"为例，插入#和$这两个特殊符号后，变成了S[] = "$#1#2#2#1#2#3#2#1#"，然后用一个数组P[i]来记录以字符S[i]为中心的最长回文子串向左或向右扩张的长度（包括S[i]）。

这样，给定了S[i]之后，便能根据S[i]计算出P[i]，如下：

S[i]：# 1 # 2 # 2 # 1 # 2 # 3 # 2 # 1 #

P[i]：1 2 1 2 5 2 1 4 1 2 1 6 1 2 1 2 1

可以看出，max(P[i]−1)正好是原字符串中最长回文子串的总长度。例如，在上述例子中，其最长回文子串的长度为5。

接下来怎么计算P[i]呢？Manacher算法增加两个辅助变量id和mx，其中id表示最大回文子串中心的位置，mx则为id+P[id]，也就是最大回文子串的边界。此时得到一个很重要的结论：如果mx>i，那么P[i]≥min(P[2 id − i], mx − i)。

下面来证明上述结论。令j = 2 id − i，也就是说，j是i关于id的对称点。

当mx − i > P[i]的时候，以S[j]为中心的回文子串被包含在以S[id]为中心的回文子串中，由于i和j对称，以S[i]为中心的回文子串必然被包含在以S[id]为中心的回文子串中，所以必有P[i]= P[j]，如图1-1所示。

图1-1

当P[i]≥mx−i的时候，以S[j]为中心的回文子串不一定被完全包含于以S[id]为中心的回文子串中，但是基于对称性可知，图1-2中所示的两个框所包围的部分是相同的。也就是说，以S[i]为中心的回文子串向右至少会扩展到mx的位置，从而有P[i]≥mx−i。至于mx之后的部分是否对称，再具体匹配。

图1-2

此外，对于mx≤i的情况，因为无法对P[i]做更多的假设，只能让P[i]=1，然后再继续进行相关匹配。

参考代码如下：

void Manacher()
{
 　　int i;
 　　int mx = 0;
 　　int id;
 　　for (i = 1; i<n; i++)
 　　{
 　　　　// mx > i时，P[i] >= Min(P[2 * id - i], mx - i)
 　　　　if (mx > i)
 　　　　{
 　　　　　　p[i] = MIN(p[2 * id - i], mx - i);
 　　　　}
 　　　　else
 　　　　{
 　　　　　　// mx <= i时，无法对P[i]做更多的假设，直接让P[i] = 1
 　　　　　　p[i] = 1;
 　　　　}
 　　　　while (s[i + p[i]] == s[i - p[i]])
 　　　　{
 　　　　　　p[i]++;
 　　　　}
 　　　　if (p[i] + i > mx)
 　　　　{
 　　　　　　mx = p[i] + i;
 　　　　　　id = i;
 　　　　}
 　　}
}

综上所述，Manacher算法使用id和mx做配合，可以在每次循环中直接对P[i]快速赋值，从而在计算以i为中心的回文子串的过程中，不必每次都从1开始比较，减少了比较次数，最终使得求解最长回文子串的长度达到线性时间复杂度O(n)。

举一反三

输出最长回文子串

将一个很长的字符串分割成一段一段的子串，要求子串都是回文串。有回文串就输出最长的，没有回文串就将字符一个个输出。例如，如果输入"habbafgh"，则输出"h, abba, f, g, h"。

本章习题

1．字符串反转

实现字符串反转函数。例如，"July"反转后变成"yluJ"。

2．字符的左右移动

给定一个字符串，这个字符串为*号和26个字母的任意组合。现在需要把字符串中的*号都移动到最左侧，而把字符串中的字母移到最右侧并保持相对顺序不变，要求时间复杂度和空间复杂度最小。

3．字符个数的统计

给定一个字符串，写一个函数，查找出该字符串中每个字符出现的次数，要求区分大小写，且时间复杂度为O(n)。

4．字符串的匹配

在一篇英文文章中查找指定的人名，人名使用26个英文字母（可以是大写或小写）、空格及两个通配符（*和?）组成。通配符*表示零个或多个任意字母，通配符?表示一个任意字母。例如，"J* Smi??"可以匹配"John Smith"。

5．字符串空格的压缩

给定一个字符串，将其中连续出现的空格压缩为1个后，将其中以空格分隔的每个字符串逆序打印出来。例如，"abc efg hij"的打印结果为"cba gfe jih"。

6．重复字符的压缩

通过键盘输入一串小写字母（a～z）组成的字符串。请编写一个字符串压缩程序，对字符串中连续出现的重复字母进行压缩，并按要求输出压缩后的字符串。

具体压缩规则是：仅压缩连续重复出现的字符。例如，字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc"。压缩后输出的格式要求为有重复的字符按“字符重复的次数+字符”输出，无格式的字符原样输出。例如，字符串"xxxyyyyyyz"压缩后输出为"3x6yz"，字符串"cccddecc"压缩后输出为"3c2de2c"，字符串"adef"压缩后输出为"adef"，字符串"pppppppp"压缩后输出为"8p"。

7．第一个只出现一次的字符

在一个字符串中找到第一个只出现一次的字符。例如，输入"abaccdeff"，则输出b。

8．删除特定的字符

给定一个原始字符串和模式字符串，要求在原始字符串中删除所有在模式字符串中出现过的字符，对应位置用空格占位。要求性能最优。例如，原始字符串为"They are students. "，模式字符串为"aeiou"，那么删除之后得到的字符串为"Thy r stdnts. "。

9．字符串集合的合并

给定一些字符串的集合，要求将其中交集不为空的集合合并，且合并完成后的集合之间无交集。例如，当给定这些字符串的集合{aaa, bbb, ccc}、{bbb, ddd}、{eee, fff}、{ggg}、{ddd, hhh}，结果应输出{aaa, bbb, ccc, ddd, hhh}、{eee, fff}、{ggg}。

提示：

这种不相交集合的合并及查询问题，可以考虑使用并查集解决。

10．集合的差集

已知集合A和集合B的元素分别用不含头结点的单向链表存储，求集合A与集合B的差集，并将结果保存在集合A的单向链表中。例如，若集合A={5, 10, 20, 15, 25, 30}，集合B={5, 15, 35, 25}，它们的差集为A={10, 20, 30}。

11．最小子串

给一篇文章，这篇文章是由一个个单词组成的，单词之间用空格隔开，再给一个字符串指针数组，如 char *str[]={"hello", "world", "good"}。求给定文章中包含这个字符串指针数组的最短字符串。

提示：

只要包含即可，没有顺序要求。

12．最长连续字符

用递归算法写一个函数，求字符串最长连续字符的长度。例如，"aaaabbcc"的最长连续字符的长度为4，"aabb"的最长连续字符的长度为2，"ab"的最长连续字符的长度为1。

13．最长重复出现子串

给定一个字符串，求出其最长的重复子串。例如，输入"abczzacbca"，输出结果是"bc"；输入"canffcancd"，输出结果是"can"。

提示：

可以使用后缀数组，对一个字符串生成相应的后缀数组后，再排序，排完序依次检测相邻的两个字符串开头的公共部分。

14．最长公共子串

给定字符串A和字符串B，输出A和B中的第一个最长公共子串。例如，给定A="wepiabc"和B="pabcni"，则输出"abc"。

15．均分01

给定一个字符串，长度不超过100，其中只包含字符'0'和'1'，并且字符'0'和'1'出现的次数都是偶数。可以把字符串任意切分，把切分后的字符串任意分给两个人，让两个人得到的0的总个数相等，得到的1的总个数也相等。例如，输入串是"010111"，可以把串切为"01"、"011"和"1"，把第1段和第3段放在一起分给一个人，第二段分给另外一个人，这样每个人都得到了1个0和2个1。要做的是让切分的次数尽可能少。考虑到最差情况，则是把长度为n的字符串切分n-1次，形成n个长度为1的字符串。

16．五笔编码

五笔的编码范围是a～y的25个字母，1～4位的编码，如果把五笔的编码按字典序排序，形成一个数组，如a, aa, aaa, aaaa, aaab, aaac,…, b, ba, baa, baaa, baab, baac,…, yyyw, yyyx, yyyy。其中a对应的数组下标为0，aa对应的数组下标为1，aaa对应的数组下标为2，依次类推。

（1）编写一个函数，输入任意一个编码，如baca，输出这个编码对应的数组下标。

（2）编写一个函数，输入任意一个下标，如12345，输出这个下标对应的编码。

17．最短摘要生成

在百度或谷歌搜索框中敲入笔者的博客名称的前4个字“结构之法”，便能在第一个搜索项看到该博客的链接，如图1-3所示。

图1-3

在图1-3中，搜索结果“结构之法算法之道-博客频道-CSDN.NET”下有一段说明性的文字：“程序员面试、算法研究、编程艺术、红黑树4大经典原创系列集锦与总结作者：July--结构之法算法…”。我们把这段文字称为此搜索结果的摘要，亦即最短摘要。请问，这个最短摘要是怎么生成的？

18．合法字符串

用n个不同的字符（编号1～n）组成一个字符串，有如下两点要求。

（1）对于编号为i 的字符，如果2i > n，则该字符可以作为最后一个字符，但是如果该字符不作为最后一个字符，则该字符后面可以接任意字符。

（2）对于编号为i的字符，如果2i≤n，则该字符不可以作为最后一个字符，且该字符后面紧接着的下一个字符的编号一定要大于等于2i。

问有多少长度为m且符合条件的字符串。例如，n = 2，m = 3。则"abb"、"bab"和"bbb"是符合条件的字符串，其余的均为不符合条件的字符串。假定n和m皆满足2≤n, m≤1 000 000 000。

本文仅用于学习和交流目的，不代表异步社区观点。非商业转载请注明作译者、出处，并保留本文的原始链接。