字符串常见算法题
左旋转字符串
在字符串上定义反转的操作XT，即把X的所有字符反转（如X="abc"，那么XT="cba"）。如果将一个字符串分成两部分，X和Y两个部分，那么我们可以得到下面的结论：(XTYT)T=YX。
定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。 如把字符串abcdef左旋转2位得到字符串cdefab。按照字符串反转的结论，X="ab"，Y="cdef"，要想把XY变成YX，只要使用YX=(XTYT)T 即可，也就是分别对X、Y进行反转，然后再整体反转一次即可。
翻转句子中单词的顺序
问题描述：
输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。句子中单词以空格符隔开。为简单起见，标点符号和普通字母一样处理。
例如输入“I am a student.”，则输出“student. a am I”。
思路：
借鉴字符串旋转的方法，我们先颠倒句子中的所有字符。这时，不但翻转了句子中单词的顺序，而且单词内字符也被翻转了。我们再颠倒每个单词内的字符。由于单词内的字符被翻转两次，因此顺序仍然和输入时的顺序保持一致。还是以上面的输入为例子。翻转“I am a student.”中所有字符得到“.tneduts a ma I”，再翻转每个单词中字符的顺序得到“students. a am I”，正是符合要求的输出。
void Reverse(char *pBegin, char *pEnd)
{
if (pBegin == NULL || pEnd == NULL)
return;
char temp;
while (pBegin < pEnd) {
temp = *pBegin;
*pBegin = *pEnd;
*pEnd = temp;
pBegin ++, pEnd --;
}
}
char* ReverseSentence(char *pData)
{
if(pData == NULL)
return NULL;
char *pBegin = pData;
char *pEnd = pData;
while(*pEnd != '\0')
pEnd ++;
pEnd--;
// Reverse the whole sentence
Reverse(pBegin, pEnd);
// Reverse every word in the sentence
pBegin = pEnd = pData;
while(*pBegin != '\0') {
if(*pBegin == ' ') {
pBegin ++;
pEnd ++;
continue;
// A word is between with pBegin and pEnd, reverse it
} else if(*pEnd == ' ' || *pEnd == '\0') {
Reverse(pBegin, --pEnd);
pBegin = ++pEnd;
} else {
pEnd ++;
}
}
return pData;
}
字符串的编辑距离
将两个不同的字符串变得相同，具体的操作方法为：
1、修改一个字符（如 把"a"替换为"b"）；
2、增加一个字符（如 把"abdd"变为"aebdd"）；
3、删除一个字符（如 把"travelling"变为"traveling"）；
首先，两个字符串的距离肯定不超过它们的长度之和（可以通过删除操作把两个串都转化为空串）。
如果两个字符串A和B的第一个字符相同，则问题转化为求A[2:lenA]和B[2:lenB]的编辑距离；
如果两个字符串A和B的第一个字符不同，可以作如下操作：
1、删除A[1]，然后计算A[2:lenA]和B[1:lenB]的距离；
2、删除B[1]，然后计算A[1:lenA]和B[2:lenB]的距离；
3、修改A[1]，使之等于B[1]，然后计算A[2:lenA]和B[2:lenB]的距离；
4、修改B[1]，使之等于A[1]，然后计算A[2:lenA]和B[2:lenB]的距离；
5、将B[1]放到A串前，然后计算A[1:lenA]和B[2:lenB]的距离；
6、将A[1]放到B串前，然后计算A[2:lenA]和B[1:lenB]的距离；
其实，我们不需要关心字符串是如何变得相同的，所以，上面6个操作可以合并为：
1、一步操作之后，计算A[2:lenA]和B[1:lenB]的距离；
2、一步操作之后，计算A[1:lenA]和B[2:lenB]的距离；
3、一步操作之后，计算A[2:lenA]和B[2:lenB]的距离；
#define MIN_META(a,b) (a>b?b:a )
#define MIN(a,b,c) MIN_META(MIN_META(a,b), c)
int CalculateStringDistance(char *A, int startA, int endA, char *B, int startB, int endB)
{
if (startA > endA) {
if (startB > endB) {
return 0;
} else {
return endB - startB + 1;
}
}
if (startB > endB) {
if (startA > endA) {
return 0;
} else {
return endA - startA + 1;
}
}
if (A[startA] == B[startB]) {
return CalculateStringDistance(A, startA+1, endA, B, startB+1, endB);
} else {
int t1 = CalculateStringDistance(A, startA+1, endA, B, startB, endB);
int t2 = CalculateStringDistance(A, startA, endA, B, startB+1, endB);
int t3 = CalculateStringDistance(A, startA+1, endA, B, startB+1, endB);
return MIN(t1,t2,t3)+1;
}
}
int main()
{
char str1[] = "Hello World";
char str2[] = "Hillo Worl";
int len1 = strlen(str1);
int len2 = strlen(str2);
int d = CalculateStringDistance(str1, 0, len1, str2, 0, len2);
printf("Distance=%d\n", d);
return 0;
}
第一个只出现一次的字符
问题描述：
在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b。
思路：
我们可以在第一次扫描字符串的时候，把每个字符出现的次数记录到一个容器中（hash结构），然后第二次扫描的时候，再读这个容器，就知道每个字符出现的次数。
char FirstNotRepeatingChar(char* pString)
{
if (!pString) return 0;
// get a hash table, and initialize it
const int tableSize = 256;
unsigned int i, hashTable[tableSize];
for (i = 0; i < tableSize; ++ i)
hashTable[i] = 0;
// get the how many times each char appears in the string
char* pHashKey = pString;
while (*(pHashKey) != '\0')
hashTable[*(pHashKey++)] ++;
// find the first char which appears only once in a string
pHashKey = pString;
while(*pHashKey != '\0') {
if(hashTable[*pHashKey] == 1)
return *pHashKey;
pHashKey++;
}
// if the string is empty
// or every char in the string appears at least twice
return 0;
}
int main()
{
char array[] = "abcdacd";
char p = FirstNotRepeatingChar(array);
printf("the first not repeatring char: %c\n", p);
return 0;
}
注意：这里默认输入的字符串是ASCII码，因此只需要一个256大小的数组就可以容纳所有可能出现的字符。
对称字符串的最大长度
问题描述：
输入一个字符串，输出该字符串中对称的子串的最大长度。
例如输入"google"，由于该字符串里最长的对称子字符串是"goog"，因此输出4.
思路：
最暴力的解法就是遍历字符串所有的子串，然后依次检查每个子串是否是对称字符串，最后得到一个最大的对称子串。
我们换一种思路，从里向外来判断。也就是先判断子串A是不是对称的，如果A不对称，那么向该字符串两端各延长一个字符得到的字符串肯定不是对称的；如果A对称，那么只需要判断A两端延长的一个字符是不是相等的，如果相等，则延长后的字符串是对称的。
int GetLongestSymmetricalLength(char *str)
{
if (NULL == str) return 0;
char *p = str;
char *last = str + strlen(str);
char *ret = (char*)malloc(sizeof(str));
memset(ret, 0, sizeof(str));
int length = 1;
while (p < last ) {
// substrings with odd length
char *begin = p - 1;
char *end = p + 1;
while (begin >= str && end < last && *begin == *end) {
begin--;
end++;
}
int new_len = end - begin - 1;
if (new_len > length) {
length = new_len;
strncpy(ret, begin+1, length);
}
// substrings with even length
begin = p;
end = p + 1;
while (begin >= str && end < last && *begin == *end) {
begin--;
end++;
}
new_len = end - begin - 1;
if (new_len > length) {
length = new_len;
strncpy(ret, begin+1, length);
}
p++;
}
printf("got %s\n", ret);
free(ret);
return length;
}
字符串的排列
问题描述：
输入一个字符串，打印出该字符串中字符的所有排列。
例如输入字符串abc，则输出由字符a、b、c所能排列出来的所有字符串abc、acb、bac、bca、cab、cba。
思路：
以三个字符abc为例来分析一下求字符串排列的过程。首先我们固定第一个字符a，求后面两个字符bc的排列。当两个字符bc的排列求好之后，我们把第一个字符a和后面的b交换，得到bac，接着我们固定第一个字符b，求后面两个字符ac的排列。现在是把c放到第一位置的时候了。记住前面我们已经把原先的第一个字符a和后面的b做了交换，为了保证这次c仍然是和原先处在第一位置的a交换，我们在拿c和第一个字符交换之前，先要把b和a交换回来。在交换b和a之后，再拿c和处在第一位置的a进行交换，得到cba。我们再次固定第一个字符c，求后面两个字符b、a的排列。既然我们已经知道怎么求三个字符的排列，那么固定第一个字符之后求后面两个字符的排列，就是典型的递归思路了。
void swap(char *a, char *b)
{
if (NULL == a || NULL == b || a ==b ) return;
*a ^= *b;
*b ^= *a;
*a ^= *b;
}
void Permutation(char *str, char *begin)
{
if (!str || !begin)
return;
if (*begin == '\0') {
printf("%s\n", str);
} else {
char *p;
for (p = begin; *p != '\0'; p++) {
swap(p, begin);
Permutation(str, begin + 1); // recursive
swap(p, begin);
}
}
}
int main()
{
char str[] = "abcd";
Permutation(str, str);
return 0;
}
如果输入的字符串有重复字符，要考虑不要出现重复的排列项：
void Permutation(char *str, char *begin)
{
if (!str || !begin)
return;
if (*begin == '\0') {
printf("%s\n", str);
} else {
char *p;
for (p = begin; *p != '\0'; p++) {
if (strchr(begin, *p) == p) {
swap(p, begin);
Permutation(str, begin + 1); // recursive
swap(p, begin);
}
}
}
}
如上面的红色部分，如果当前*p的字符（即准备与*begin交换的字符）在前面的子字符串中是否出现过了，若出现了，就不交换，若没出现就交换
字符串的组合
问题描述：
输入一个字符串，输出该字符串中字符的所有组合。
例如如果输入abc，它的组合有a、b、c、ab、ac、bc、abc。
思路：
假设我们想在长度为n的字符串中求m个字符的组合。我们先从头扫描字符串的第一个字符。针对第一个字符，我们有两种选择：一是把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选取m-1个字符；而是不把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选择m个字符。这两种选择都很容易用递归实现。
C++代码实现：
bool IsContinuous(vector<int> numbers, int maxNumber)
{
if(numbers.size() == 0 || maxNumber <=0)
return false;
// Sort the array numbers.
sort(numbers.begin(), numbers.end());
int numberOfZero = 0;
int numberOfGap = 0;
// how many 0s in the array?
vector<int>::iterator smallerNumber = numbers.begin();
for (; smallerNumber != numbers.end(); ++smallerNumber) {
if (*smallerNumber == 0) {
numberOfZero++;
} else {
break;
}
}
// get the total gaps between all adjacent two numbers
vector<int>::iterator biggerNumber = smallerNumber + 1;
while (biggerNumber < numbers.end()) {
// if any non-zero number appears more than once in the array,
// the array can't be continuous
if (*biggerNumber == *smallerNumber)
return false;
numberOfGap += *biggerNumber - *smallerNumber - 1;
smallerNumber = biggerNumber;
++biggerNumber;
}
return (numberOfGap > numberOfZero) ? false : true;
}
void Combination(char* string, int number, vector<char>& result)
{
if(number == 0) {
vector<char>::iterator iter = result.begin();
for (; iter < result.end(); ++ iter) cout<<*iter;
cout<<endl;
return;
}
if(*string == '\0') return;
result.push_back(*string);
Combination(string + 1, number - 1, result);
result.pop_back();
Combination(string + 1, number, result);
}
void Combination(char* string, int length)
{
if (string == NULL || length <= 0) return;
vector<char> result;
for (int i = 1; i <= length; ++ i) {
Combination(string, i, result);
}
}
int main()
{
char str[] = "abcd";
Combination(str, sizeof(str) - 1);
}
最长不重复子串
给定一个字符串，找出这个字符串中最长的不重复子串。
比如对于字符串“sadus”，那么返回的结果应该是“sadu”或者“adus”（返回一个即可）；
int lengthOfLongestSubstring(string s) {
vector<int> dict(256, -1);
int maxLen = 0, start = -1;
for (int i = 0; i != s.length(); i++) {
if (dict[s[i]] > start)
start = dict[s[i]];
dict[s[i]] = i;
maxLen = max(maxLen, i - start);
}
return maxLen;
}
最长公共子串（Longest Common Substring）
子字符串的定义和子序列的定义类似，但要求是连续分布在其他字符串中。比如输入两个字符串BDCABA和ABCBDAB的最长公共字符串有BD和AB，它们的长度都是2。
X = <a, b, c, f, b, c>
Y = <a, b, f, c, a, b>
X和Y的最长公共子串（Longest Common Sequence）为<a, b, c, b>，长度为4；
X和Y的最长公共子序列（Longest Common Substring）为 <a, b>，长度为2。
对于最长公共子串问题，可以用一个二维矩阵来记录中间的结果，最长斜对角线即对应最长连续子串；
例如： ABBEDGHK与CCHENBEDHKH 的最长公共子串是“ BED”：
xi表示横轴第i个字符的值，yj表示纵轴第j个字符的值，c[i][j]表示矩阵某位置的累积值，则动态转移方程为：
如果xi ! = yj, 那么c[i][j] = 0；
如果xi == yj， 则 c[i][j] = c[i-1][j-1]+1。
最后求Longest Common Substring的长度等于：
max{ c[i][j], 1<=i<=n， 1<=j<=m}
void longest_common_substring(char *str1, char *str2)
{
int i,j,x,y;
int len1 = strlen(str1);
int len2 = strlen(str2);
int c[len1][len2]; // 使用变量作为数组长度是一种灰色的做法
memset(c, 0, len1*len2*sizeof(int));
int max = 0;
for (i=0; i<len1; i++) {
for (j=0; j<len2; j++) {
if (str1[i] == str2[j]) {
if (i==0 || j==0) {
c[i][j] = 1;
} else {
c[i][j] = c[i-1][j-1] + 1;
}
}
if (c[i][j] > max) {
max = c[i][j];
x=i;
y=j;
}
}
}
char s[max+1];
int k = max;
s[k--] = 0;
for(i=x,j=y; i>=0 && j>=0; i--,j--) {
if (str1[i]==str2[j]) {
s[k--] = str1[i];
} else {
break;
}
}
printf("LCS：%s\n", s);
}
最长公共子序列（Longest Common Subsequence）
考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bn-1”，并Z=“z0，z1，…，zk-1”为它们的最长公共子序列。不难证明有以下性质：
（1） 如果am-1==bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最长公共子序列；
（2） 如果am-1!=bn-1，且zk-1!=am-1时，则蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列；
（3） 如果am-1!=bn-1，且zk-1!=bn-1时，则蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列。
这样，在找A和B的公共子序列时，如果有am-1==bn-1，则进一步解决一个子问题，找“a0，a1，…，am-2”和“b0，b1，…，bm-2”的一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子序列。
引进一个二维数组c[][]，用c[i][j]记录x0,x1,...,xi与y0,y1,...,yj 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定输出最长公共字串时搜索的方向。
我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] == Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。
问题的递归式写成：
回溯输出最长公共子序列过程：
由于每次调用至少向上或向左（或向上向左同时）移动一步，故最多调用(m + n)次就会遇到i = 0或j = 0的情况，此时开始返回。返回时与递归调用时方向相反，步数相同，故算法时间复杂度为Θ(m + n)。
void PrintLCS(int **b, char *str1, int i, int j)
{
if (i==0 || j==0) return ;
if (b[i][j]==0) {
PrintLCS(b, str1, i-1, j-1); //从后面开始递归，所以要先递归到子串的前面，然后从前往后开始输出子串
printf("%c",str1[i-1]); //c[][]的第i行元素对应str1的第i-1个元素
} else if(b[i][j]==1) {
PrintLCS(b, str1, i-1, j);
} else {
PrintLCS(b, str1, i, j-1);
}
}
void longest_common_subsequence(char* str1, char* str2)
{
int i,j;
int len1 = strlen(str1);
int len2 = strlen(str2);
int **b = malloc((len1+1)*sizeof(int*));
for (i=0; i<=len1; i++) {
b[i] = malloc((len2+1) * sizeof(int));
memset(b[i], 0, len2 * sizeof(int));
}
int **c = malloc((len1+1)*sizeof(int*));
for (i=0; i<=len1; i++) {
c[i] = malloc((len2+1) * sizeof(int));
memset(c[i], 0, len2 * sizeof(int));
}
for (i=1; i<=len1; i++) {
for (j=1; j<=len2; j++) {
if (str1[i-1] == str2[j-1]) {
c[i][j] = c[i-1][j-1] + 1;
b[i][j] = 0; //输出公共子串时的搜索方向
} else if (c[i-1][j] > c[i][j-1]) {
c[i][j] = c[i-1][j];
b[i][j] = 1;
} else {
c[i][j] = c[i][j-1];
b[i][j] = -1;
}
}
}
printf("length of LCS=%d\n", c[len1][len2]);
PrintLCS(b, str1, len1, len2);
}
从字符串中删除指定字符
利用两个指针，一个读指针，一个写指针，读指针在每个循环中走一步，写指针根据当前读取的字符来决定是否前进。
如果读到的当前字符是要删除的字符，则写指针原地不动，等待下一个读操作来赋值。
static void DelInStr(char* str, char c)
{
char *pr = str;
char *pw = str;
while (*pr) {
*pw = *pr++;
pw += (*pw != c);
}
*pw = '\0';
}
假如要从字符串中删除多个指定的字符，方法也是一样的，同样是判断当前读到的字符是否是待删除字符中的一个。
判断可以使用一个循环，将当前字符与所有要删除的字符依次比较，这样做效率比较慢，我们考虑用一个hash的结构来代替查找过程。
我们知道一个ASCII字符表示的范围是0～255，故我们构造一个长度为256的数组，并将其所有元素初始化为0，然后将要删除字符的ASCII码作为索引的元素置1。
static void DelInStr(char* str, char* c)
{
char *pr = str;
char *pw = str;
int n = 0;
short flag[256];
memset(flag, 0, 256);
while (c[n] != '\0') {
flag[c[n++]] = 1;
}
while (*pr) {
*pw = *pr++;
pw += (flag[*pw] == 0);
}
*pw = '\0';
}
int main()
{
char str[] = "Hello World, I am from China!";
DelInStr(str, "loa");
printf("%s\n", str);
return 0;
}
打印的结果为：He Wrd, I m frm Chin!
OK，删除单个或多个字符问题解决了，让我们把它再拓展一下，如果是要从一个字符串中删除一个子串，应该怎么做呢？
对这个问题，通常最直接、最粗暴的反应是利用strstr函数找到子串，然后memmove把子串后面的剩余串往前覆盖，实现如下：
static void DelInStr2(char* str, char* del)
{
char *p;
int n = strlen(del);
while (p = strstr(str, del)) {
memmove(p, p+n, strlen(p+n)+1);
}
}
int main()
{
char str[] = "world, hello, i wanna get rid of world here world";
DelInStr2(str, "world");
printf("%s\n", str);
return 0;
}
打印的结果为：, hello, i wanna get rid of here
这个实现的复杂度也取决于库函数memmove的调用次数，如果子串出现的次数较多，则需要频繁移动字符串，这样做似乎也不是个好主意。但我还没有想到更好的办法。
