常见字符串算法题

1. 拓扑结构相同的子树

对于两棵彼此独立的二叉树A和B，请编写一个高效算法，检查A中是否存在一棵子树与B树的拓扑结构完全相同，节点取值也要相同。

给定两棵二叉树的头结点A和B，请返回一个bool值，代表A中是否存在一棵同构于B的子树。

思路1：遍历树A，若遍历到的节点C取值与B的根节点取值一样，则判断以B为根和以C为根的树结构是否相同。时间复杂度：O(N*M)。 N：A的节点数，M：B的节点数。

思路2：将树A和树B序列化为字符串，然后用KMP算法在字符串A中寻找子串B。时间复杂度：O(N+M)

知识点：树的遍历；树结构匹配；树的序列化；KMP算法

// 思路1
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class IdenticalTree {
public:
    bool chkIdentical(TreeNode* A, TreeNode* B) {
        if (B==NULL) return true;
        return pre_order(A, B);
    }
    bool pre_order(TreeNode* A, TreeNode* B){
        if(A==NULL) return false;
        bool flag=false;
        if(A->val == B->val)
            flag = judge(A, B);
        if(flag) 
            return true;
        else
            return pre_order(A->left, B) || pre_order(A->right, B);
    }
    
    bool judge(TreeNode* root1, TreeNode* root2){
        if(root1 == NULL && root2 == NULL) return true;
        if(root1 == NULL && root2 != NULL) return false;
        if(root1 != NULL && root2 == NULL) return false;
        if(root1->val != root2->val) return false;
        return judge(root1->left, root2->left) && judge(root1->right, root2->right);
    }
};

// 思路2
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class IdenticalTree {
public:
    bool chkIdentical(TreeNode* A, TreeNode* B) {
        string strA = pre_serial(A);
        string strB = pre_serial(B);
        int idx = kmp_search(strA, strB);
        return idx != -1;
    }
    
    string pre_serial(TreeNode* root){
        if(root==NULL) return "#!";
        string res = std::to_string(root->val)+"!";
        res += pre_serial(root->left);
        res += pre_serial(root->right);
        return res;
    }
    
    int kmp_search(string s, string p){
        int len_s=s.length(), len_p=p.length();
        int* next = getNext(p);
        int i=0, j=0;
        while(i<len_s && j<len_p){
            if(s[i] == p[j] || j==-1){
                ++i;
                ++j;
            }else{
                j = next[j];
            }
        }
        return j==len_p ? i-j : -1;
    }
    
    int* getNext(string p){
        int len = p.length();
        int* next = new int[len];
        next[0] = -1;
        
        int k=-1, j=0;
        while(j<len-1){
            if(k==-1 || p[j]==p[k]){
                if(p[j+1] == p[k+1])
                    next[++j] = next[++k];
                else
                    next[++j] = ++k;
            }else
                k = next[k];
        }
        return next;
    }
};

2. 词语变形题

对于两个字符串A和B，如果A和B中出现的字符种类相同且每种字符出现的次数相同，则A和B互为变形词，请设计一个高效算法，检查两给定串是否互为变形词。

给定两个字符串A和B及他们的长度，请返回一个bool值，代表他们是否互为变形词。

思路：C++字符的取值范围为0-255，Java为0-65535。可以设置一个大小为256的数组，存储A中出现的每个字符的计数。B同理。然后比较两个计数数组是否相等。

知识点：字符取值范围；给定取值范围时，可用数组模拟哈希表，效率更高。

class Transform {
public:
    bool chkTransform(string A, int lena, string B, int lenb) {
        int* cntA=new int[256]();
        int* cntB=new int[256]();
        for(int i=0; i<lena; ++i)
            ++cntA[A[i]];
        for(int i=0; i<lenb; ++i)
            ++cntB[B[i]];
        for(int i=0; i<256; ++i)
            if(cntA[i] != cntB[i])
                return false;
        return true;
    }
};

3. 判断串的旋转

如果对于一个字符串A，将A的前面任意一部分挪到后边去形成的字符串称为A的旋转词。比如A="12345",A的旋转词有"12345","23451","34512","45123"和"51234"。对于两个字符串A和B，请判断A和B是否互为旋转词。

给定两个字符串A和B及他们的长度lena，lenb，请返回一个bool值，代表他们是否互为旋转词。

思路：令C=A+A, 然后在C中用KMP算法查找子串B。

4. 句子的逆序

给定一个原字符串A和他的长度，请返回逆序后的字符串。如输入："dog loves pig",13，返回："pig loves dog"。

思路：实现一个逆序函数，然后对整个句子逆序，然后对单词逆序。

 5. 最大回文子串 LeetCode 5

class Solution {
public:
    string longestPalindrome(string s) {
        int len = 0;
        string str;
        // 遍历每一个位置，作为中心点
        for(int i=0; i<s.size(); ++i)
        {
            // 查找aba模式回文串
            for(int j=0; i-j>=0 && i+j<s.size(); ++j)
                if(s[i-j] == s[i+j])
                {
                    if(2*j+1 > len)
                    {
                        str = s.substr(i-j, 2*j+1);
                        len = 2*j+1;
                    }
                }
                else break;
            // 查找abba模式回文串
            for(int l=i,r=i+1; l>=0&&r<s.size(); --l,++r)
                if(s[l] == s[r])
                {
                    if(r-l+1 > len)
                    {
                        str = s.substr(l, r-l+1);
                        len = r-l+1;
                    }
                }
                else break;
        }
        return str;
    }
};