数据结构：字符串 C++

题目来自于

https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.00.md

非常感谢July大神和众网友。

本博文初衷是为了方便自己准备面试，有一篇文章可以看所有的东西，省的翻来翻去。

代码是手打的Qt C++，解法中不考虑实现最简单的毫无难度的暴力解法了。

因为很短，不区分*.cc和*.hh文件了，都写在一起；注释初衷也是为了自己理解。

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

1.1 旋转字符串

题目描述

给定一个字符串，要求把字符串前面的若干个字符移动到字符串的尾部，如把字符串“abcdef”前面的2个字符'a'和'b'移动到字符串的尾部，使得原字符串变成字符串“cdefab”。请写一个函数完成此功能，要求对长度为n的字符串操作的时间复杂度为 O(n)，空间复杂度为 O(1)。

分析与C++实现

// 编程之美：1.1旋转字符串

// 题目：给定一个字符串，要求把字符串前面的若干个字符移动到字符串的尾部，

// 如把字符串“abcdef”前面的2个字符'a'和'b'移动到字符串的尾部，使得原

// 字符串变成字符串“cdefab”。请写一个函数完成此功能，要求对长度为n的字

// 符串操作的时间复杂度为 O(n)，空间复杂度为 O(1)。

#include <iostream>

#include <string>

using namespace std;

// 记得用reference，不然改变后的string传不回来

void leftShiftString(string& str, int shiftNum);

void reverseString(string& str, int from, int to);

void rotate(string& str, int shiftNum);

int main()

    string test_str = "abcd";

    int shiftNumber = 2;

    cout << "before: " << test_str << endl;

    //leftShiftString(test_str, shiftNumber);

    rotate(test_str, shiftNumber);

    cout << "after : " << test_str << endl;

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// 推荐解法： 三步翻转法

// 将一个字符串分成X和Y两个部分，在每部分字符串上定义反转操作，如X^T，即把X的所有字符反转

// （如，X="abc"，那么X^T="cba"），那么就得到下面的结论：(X^TY^T)^T=YX，显然就解决了字符串的反转问题。

// 例如，字符串 abcdef ，若要让def翻转到abc的前头，只要按照下述3个步骤操作即可：

// 1) 首先将原字符串分为两个部分，即X:abc，Y:def；

// 2) 将X反转，X->X^T，即得：abc->cba；将Y反转，Y->Y^T，即得：def->fed。

// 3) 反转上述步骤得到的结果字符串X^TY^T，即反转字符串cbafed的两部分（cba和fed）给予反转，

//    cbafed得到defabc，形式化表示为(X^TY^T)^T=YX，这就实现了整个反转。

void leftShiftString(string& str, int shiftNum)

    int str_len = str.length();

    if (str_len == 0)

        // 空串忽视

        return;

    }else

        // 取模两个好处：一是避免不必要的移动，

        // 二是防止index越界，尤其是shiftNum可能有负值，这时候要加上str_len避免取模返回负值

        shiftNum = (shiftNum + str_len) % str_len;

    if (shiftNum == 0)

        //移动0位可以直接返回

        return;

    // 原字符串的X部分 -> X^T

    reverseString(str, 0, shiftNum - 1);

    cout << "X part: " << str << endl;

    // 原字符串的Y部分 -> Y^T

    reverseString(str, shiftNum, str_len - 1);

    cout << "Y part: " << str << endl;

    // (X^TY^T)^T ->　YX

    reverseString(str, 0, str_len - 1);

    cout << "Both part: " << str << endl;

void reverseString(string& str, int from, int to)

    while(from < to)

        swap(str[from++], str[to--]);

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

//其他解法： 不是很通用，但是我自己想出来的，见

//http://blog.csdn.net/u013300875/article/details/44126909

//思路简单说就是我们知道str_len，也知道shiftNum，所以对于一个特定位置current的字符，

//它的目标位置target其实就确定了，我们只要把这它从current移动到target就行了

void rotate(string& str, int shiftNum)

    int str_len = str.length();

    if (str_len == 0)

        // 空串忽视

        return;

    if (shiftNum == 0)

        //移动0位可以直接返回

        return;

    //每个字符应该只被移动一次，也必须也被移动一次

    //所以我们在 count == str_len 时停止

    int count = 0;

    for (int i = 0; i < str_len ; ++i)

        int index = i;

        char tmp = str[index];

        while(1)

            count++;

            // 在index位置的字符将被移动到index+new

            int index_new = (index - shiftNum + str_len) % str_len;

            // 把index_new位置的元素保存到空出来的i位置

            str[i] = str[index_new];

            // 完成str[index] ->　str[index_new]的移动

            str[index_new] = tmp;

            // 准备处理原来位于index_new的字符

            tmp = str[i];

            index = index_new;

            // 如果我们已经处理了所有的字符，即完成了一个圈

            // 我们是从i这个位置开始处理的，如果我们下一个要处理的又是i，

            // 我们可以跳过它了

            if (i == index)

                break;

        if (count == str_len)

            break;

1.2 字符串包含

题目描述

给定两个分别由字母组成的字符串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。

分析与C++实现

// 编程之美：1.2 字符串包含

// 题目：给定两个分别由字母组成的字符串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。

#include <iostream>

#include <string>

#include <map>

using namespace std;

bool StringContains(string &str1, string &str2);

int main()

    string str1 = "ABCD";

    string str2 = "BAD";

    string str3 = "BCE";

    cout << StringContains(str1, str2) << endl;

    cout << StringContains(str1, str3) << endl;

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// 推荐解法： HashTable

// 可以先把长字符串str1中的所有字符都放入一个Hashtable里，然后轮询短字符串str2，

// 看短字符串str2的每个字符是否都在HashTable里.

// 如果都存在，说明长字符串str1包含短字符串str2，否则，说明不包含。

// 再进一步，我们可以对字符串str1，用位运算（26bit整数表示)计算出一个“签名”，

// 再用str2中的字符到A里面进行查找。

// 这个方法的实质是用一个整数代替了HashTable，空间复杂度为O(1)，时间复杂度还是O(n + m)。

// But, 用26bits整数代替HashTable太取巧了，我还是觉得用STL map

// 搞一个真正的HashTable比较好，毕竟英文字母起码还有大小写呢!

// map是用红黑树实现的，插入和查询都是O(log n)，

// 插入str1的字符，n次插入； 查询str2的字符，m次查询

// 时间复杂度是O((m+n)logn)级别

bool StringContains(string &str1, string &str2)

    int str1_len = str1.length();

    int str2_len = str2.length();

    // str1 应该比 str2 长

    if ((str1_len == 0)|| (str2_len == 0) ||(str1_len <= str2_len))

        return false;

    // 用 stl map 创建一个HashTable

    map<char, bool> HashTable;

    // 插入所有的str1的字符，有的话就是true O(n)

    for (int ii = 0; ii < str1_len; ++ii)

        HashTable[str1[ii]] = true;

    // 查询每一个str2的字符，O(m)

    for (int ii = 0; ii < str2_len; ++ii)

        // bool型的默认值是false

        // 所以 HashTable['a nonexisting letter'] = false

        if (HashTable[str2[ii]] == false)

            return false;

    return true;

1.3 字符串转换成整数

题目描述

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

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

分析与C++实现

// 编程之美：1.3字符串转整数

// 题目：输入一个由数字组成的字符串，把它转换成整数并输出。

// 例如：输入字符串"123"，输出整数123。

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

#include <iostream>

#include <string>

#include <climits>

#include <ctype.h>

using namespace std;

int StrToInt(const char *str);

int main()

    string test_str = "-2147483648";

    cout << "Integer: " << StrToInt(test_str.c_str()) << endl;

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// 推荐解法：

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

// 一些细节：

// 1）空指针输入：输入的是指针，在访问空指针时程序会崩溃，因此在使用指针之前需要先判断指针是否为空。

// 2）正负符号：整数不仅包含数字，还有可能是以'+'或'-'开头表示正负整数，因此如果第一个字符是'-'号，则要把得到的整数转换成负整数。

// 3）非法字符：输入的字符串中可能含有不是数字的字符。因此，每当碰到这些非法的字符，程序应停止转换。

// 4）整型溢出：输入的数字是以字符串的形式输入，因此输入一个很长的字符串将可能导致溢出。

// 细节4特别重要，所以我们要使用#include <climits>里的宏定义INT_MAX和INT_MIN，

// 如果溢出了，就返回INT_MAX或INT_MIN

int StrToInt(const char *str)

    // 细节1) 空指针输入

    if (str == NULL)

        return 0;

    // 细节3) 非法字符中的空白字符

    while(isspace(*str))

        ++str;

    // 细节2） 正负号（可能有也可能没有，默认为+）

    int sign = 1;

    if ((*str == '+') || (*str == '-'))

        if (*str == '-')

            sign = -1;

        ++str;

    //确定是数字后才执行循环

    int n = 0;

    while (isdigit(*str))

        //处理溢出

        int c = *str - '0';

        if (sign > 0 && (n > INT_MAX / 10 || (n == INT_MAX / 10 && c > INT_MAX % 10)))

            n = INT_MAX;

            break;

        else if (sign < 0 && (-n < INT_MIN / 10 || (-n == INT_MIN / 10 && -c < INT_MIN % 10)))

            n = INT_MIN;

            break;

        //把之前得到的数字乘以10，再加上当前字符表示的数字。

        n = n * 10 + c;

        ++str;

    return sign > 0 ? n : -n;

1.4 回文判断

题目描述

回文，英文palindrome，指一个顺着读和反过来读都一样的字符串，比如madam、我爱我，这样的短句在智力性、趣味性和艺术性上都颇有特色，中国历史上还有很多有趣的回文诗。

那么，我们的第一个问题就是：判断一个字串是否是回文？

为了增加难度，改为单向链表结构的字串e.g. A->B->C->B->A 并且事先不知道字串长度

即判断一条单向链表是不是“回文”

分析与C++代码

// 编程之美：1.4回文判断

// 题目：回文，英文palindrome，指一个顺着读和反过来读都一样的字符串，

// 比如madam、我爱我，这样的短句在智力性、趣味性和艺术性上都颇有特色，中国历史上还有很多有趣的回文诗。

// 那么，我们的第一个问题就是：判断一个字串是否是回文？

// 为了增加难度，改为单向链表结构的字串e.g. A->B->C->B->A 并且事先不知道字串长度

// 即 判断一条单向链表是不是“回文”

#include <iostream>

#include <string>

#include <stack>

using namespace std;

//define node

typedef struct node* pNode;

typedef struct node

    char ch;

    pNode next;

}Node;

bool isPalindromeList(pNode myList);

bool isPalindromeList2(pNode myList);

pNode reverseList(pNode from, pNode to);

int main()

    // create a list

    pNode myList = NULL;

    pNode head = NULL;

    string init = "ABCBA";

    for(size_t ii = 0; ii < init.length(); ++ii)

        if (head == NULL)

            head = new Node;

            myList = head;

            head->ch = init[ii];

            head->next = NULL;

        }else

            head->next = new Node;

            head = head->next;

            head->ch = init[ii];

            head->next = NULL;

    // print the list

    head = myList;

    for (size_t ii = 0; ii < init.length(); ++ii)

        cout << head->ch << "->";

        head = head->next;

    cout << "NULL" << endl;

    cout << "isPalindromeList1: " << isPalindromeList(myList) << endl;

    cout << "isPalindromeList2: " << isPalindromeList2(myList) << endl;

//    // free the list

//    for (size_t ii = 0; ii < init.length(); ++ii)

//    {

//        head = myList;

//        myList = myList->next;

//        if (head != NULL)

//        {

//            delete head;

//        }

//    }

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// 解法一： 采用快慢指针，慢指针入栈，当快指针为NULL时，出栈和慢指针比较即可。

// 时间复杂度O(n),空间复杂度O(n)。

// 优点：比较好实现，且没有修改链表

// 缺点：需要分配内存

bool isPalindromeList(pNode myList)

    if (myList == NULL)

        return false;

    // 快慢指针

    pNode fast = myList;

    pNode slow = myList;

    // 需要判断整个链表有奇数个还是偶数个node

    // false是奇数个， true是偶数个

    bool evenOrOdd = true;

    stack<char> myStack;

    // 把slow移动到整个链表的中间

    while (fast != NULL)

        myStack.push(slow->ch);

        // 慢指针一步，快指针两步

        slow = slow->next;

        fast = fast->next;

        if (fast != NULL)

            fast = fast->next;

        }else

            // fast不是slow的两倍，说明是奇数个node

            evenOrOdd = false;

    // 奇数个node的情况下，正中间的那个需要出栈，不参加比较

    if (evenOrOdd == false)

        myStack.pop();

    // 现在慢指针指向了后半段链表的开头，而stack的top是

    // 前半段链表的倒序开头，可以比较了

    while ((slow != NULL) && (!myStack.empty()))

        if (slow->ch != myStack.top() )

            return false;

        slow = slow->next;

        myStack.pop();

    return true;

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// 解法二：采用快慢指针，当快指针为NULL时，翻转慢指针。

// 比较前半部分链表和翻转链表即可。时间复杂度O(n),空间复杂度O(1)。

// 优点：节约空间

// 缺点：改变了链表的值，而且后半段链表翻转后很可能和前半段链表断开了

// 最后delete 返还内存时会出现内存泄露，要前半段和后半段分别delete

pNode reverseList(pNode from, pNode to)

    pNode tmp1 = from;

    pNode tmp2 = NULL;

    while (tmp1->next != to)

        tmp2 = tmp1->next;

        tmp1->next = tmp2->next;

        tmp2->next = from;

        from = tmp2;

    return from;

bool isPalindromeList2(pNode myList)

    if (myList == NULL)

        return false;

    // 链表头指针，快慢指针

    pNode head = myList;

    pNode fast = myList;

    pNode slow = myList;

    // 把slow移动到整个链表的中间

    while (fast != NULL)

        // 慢指针一步，快指针两步

        slow = slow->next;

        fast = fast->next;

        if (fast != NULL)

            fast = fast->next;

    // 翻转后半段链表

    pNode head2 = reverseList(slow, NULL);

    // 比较前半段链表和翻转后的后半段链表

    while (head != NULL && head2 != NULL)

        if (head->ch != head2->ch)

            return false;

        head = head->next;

        head2 = head2->next;

    return true;

1.5 最长回文字串

题目描述

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

分析与C++代码

// 编程之美：1.5最长回文字串

// 题目：给定一个字符串，求它的最长回文子串的长度

#include <iostream>

#include <string>

using namespace std;

string preProcess(string str);

string longestPalindrome(string s);

int main()

    string str = "absfsfsfsfffffffffse";

    cout << str << ": " << longestPalindrome(str) << endl;

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// 推荐解法： Manacher算法

// 时间复杂度O(N)空间复杂度O(N)

// 首先用一个非常巧妙的方式，将所有可能的奇数/偶数长度的回文子串都转换成了奇数长度：

// 在每个字符的两边都插入一个特殊的符号。比如 abba 变成 #a#b#b#a#， aba变成 #a#b#a#。

// 为了进一步减少编码的复杂度，可以在字符串的开始加入另一个特殊字符，这样就不用特殊处理越界问题，

// 比如$#a#b#a#（注意，下面的代码是用C语言写就，由于C语言规范还要求字符串末尾有一个'\0'所以正好OK，

// 但其他语言可能会导致越界）。

// 下面以字符串12212321为例，经过上一步，变成了 S[] = "$#1#2#2#1#2#3#2#1#";

// 实在是太长了 看这个http://articles.leetcode.com/2011/11/longest-palindromic-substring-part-ii.html

// 或者 http://www.felix021.com/blog/read.php?2040

string preProcess(string str)

    int n = str.length();

    if (n == 0)

        return "^$";

    string ret = "^";

    for (int i = 0; i < n; i++)

        ret += "#" + str.substr(i, 1);

    ret += "#$";

    return ret;

string longestPalindrome(string s)

    string T = preProcess(s);

    int n = T.length();

    int *P = new int[n];

    int C = 0, R = 0;

    for (int i = 1; i < n-1; i++)

        int i_mirror = 2*C-i; // equals to i' = C - (i-C)

        P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0;

        // Attempt to expand palindrome centered at i

        while (T[i + 1 + P[i]] == T[i - 1 - P[i]])

            P[i]++;

        // If palindrome centered at i expand past R,

        // adjust center based on expanded palindrome.

        if (i + P[i] > R)

            C = i;

            R = i + P[i];

    // Find the maximum element in P.

    int maxLen = 0;

    int centerIndex = 0;

    for (int i = 1; i < n-1; i++)

        if (P[i] > maxLen)

            maxLen = P[i];

            centerIndex = i;

    delete[] P;

    return s.substr((centerIndex - 1 - maxLen)/2, maxLen);

1.6 字符串的全排列

题目描述

输入一个字符串，打印出该字符串中字符的所有排列。

例如输入字符串abc，则输出由字符a、b、c 所能排列出来的所有字符串

abc、acb、bac、bca、cab 和 cba。

分析与C++代码

// 编程之美：1.6字符串的全排列

// 输入一个字符串，打印出该字符串中字符的所有排列。

// 例如输入字符串abc，则输出由字符a、b、c 所能排列出来的所有字符串

// abc、acb、bac、bca、cab 和 cba。

#include <iostream>

#include <algorithm>

#include <string>

using namespace std;

bool CalcAllPermutation(string& perm);

int main()

    string str = "15342";

    // 注意next_permutation只能找到下一个字符串，但是之前的字符串无法找到

    // 所以我们必须人工保证是从最小的情况开始

    sort(str.begin(), str.end());

    cout << str << endl;

    while(1)

        if (!CalcAllPermutation(str))

            break;

        cout << str << endl;

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// 推荐解法： 字典序排列 （next permuatation算法）

// 举个例子做启发： 现在我们要找21543的下一个排列，我们可以从左至右逐个扫描每个数，

// 看哪个能增大（至于如何判定能增大，是根据如果一个数右面有比它大的数存在，那么这个数就能增大），

// 我们可以看到最后一个能增大的数是：x = 1。

// 而1应该增大到多少？1能增大到它右面比它大的那一系列数中最小的那个数，即：y = 3，

// 故此时21543的下一个排列应该变为23xxx，显然 xxx(对应之前的B’）应由小到大排，

// 于是我们最终找到比“21543”大，但字典顺序尽量小的23145，找到的23145刚好比21543大。

//由这个例子可以得出next_permutation算法流程为：

// next_permutation算法

// 定义

//    升序：相邻两个位置ai < ai+1，ai 称作该升序的首位

// 步骤（二找、一交换、一翻转）

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

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

//    交换x，y

//    把第(i+1)位到最后的部分翻转

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

//    x = 1；

//    y = 3

//    1和3交换

//    得23541

//    翻转541

//    得23145

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

// 由于全排列总共有n!种排列情况，所以时间复杂度为O(n!)

bool CalcAllPermutation(string& perm)

    int i;

    int num = perm.length();

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

    for (i = num - 2; (i >= 0) && (perm[i] >= perm[i + 1]); --i)

    // 已经找到所有排列

    if (i < 0){

        return false;

    int k;

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

    for (k = num - 1; (k > i) && (perm[k] <= perm[i]); --k)

    //③交换x，y

    swap(perm[i], perm[k]);

    //④把第(i+ 1)位到最后的部分翻转

    int from = i+1;

    int to = num-1;

    while(from < to)

        swap(perm[from++], perm[to--]);

    return true;