字符串

1.拓扑子树相同结构

a树中是否存在结构相同的b树

方法一

class IdenticalTree {
public:
    char a[101],b[101];
    int la=0,lb=0;
    int getla(TreeNode *p)
    {
        if(p==NULL)
        {
            a[la++]='\0';
        }
        else
        {
            a[la++]=p->val;
            getla(p->left);
            getla(p->right);
        }
        return la;
    }
       int getlb(TreeNode *q)
    {
        if(q==NULL)
        {
            b[lb++]='\0';
        }
        else
        {
            b[lb++]=q->val;//复制时要小心，每一个都要改
            getlb(q->left);
            getlb(q->right);
        }
        return lb;
    }
public:
    bool chkIdentical(TreeNode* A, TreeNode* B) {
        
        la=0;
        lb=0;//必须是英文;
        int i=0,j=0;
        la=getla(A);
        lb=getlb(B);
        while(i<la && j<lb)//错误处：j<<lb,一定要小心。
        {
            if(a[i]==b[j])
            {
                ++i;
                ++j;
            }
            else
            {
                i=i-j+1;//i直接加1不就行了吗？不行，需要i-j+1开始
                j=0;
            }
        }
        if(j>=lb)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};

方法二

利用库函数strstr实现

class IdenticalTree {
public:
    void serialize(TreeNode* root, string& s){
        if (root == nullptr) {
            s+="#!";
            return;
        }
        s+= std::to_string(root->val);
        s+='!';
        serialize(root->left, s);
        serialize(root->right, s);
    }
     
    bool chkIdentical(TreeNode* A, TreeNode* B) {
        string str1,str2;
        serialize(A,str1);
        serialize(B,str2);
         
        const char* pstr1 = str1.c_str();
        const char* pstr2 = str2.c_str();
 
        if (strstr(pstr1, pstr2))
            return true;
        else
            return false;
 
    }
};

方法三

可以自己实现kmp算法，来进行字符串匹配

2.词语变形

假如输入为"abc",3,"bca",3，则输出为true，字符种类和次数相同即互为变形词。

class Transform {
    public:
    
    bool compareab(int a[],int b[],int minl)
    {
            int len=0;
            for(int i=0;i<256;++i)
            {
                if(a[i]!=0&&a[i]==b[i])
                len+=a[i];
            }
            if(len==minl)
                return true;
            else 
                return false;
    }
public:
    bool chkTransform(string A, int lena, string B, int lenb) {
        
        if(lena!=lenb)
            return false;
        int a [256],b[256];
        memset(a,0,sizeof(int )*256);
        memset(b,0,sizeof(int)*256);
        for(auto &a1:A)
            a[a1]+=1;
        for(auto &b1:B)
            b[b1]+=1;
        //int len =lena<=lenb?lena:lenb;
        //if(lena<=lenb)
            //return compareab(a,b,lena);
        //else
            return compareab(a,b,lenb);
    }
};

3.判断是否互为旋转词

方法一

class Rotation {
public:
    void calnext(string &B,int *next,int lenb)
    {
        int k=0;
        next[0]=0;
        for(int i=1;i<lenb;++i)
        {
            while(k>0&&B[k]!=B[i])//k即使最大匹配前缀和后缀个数，也是前缀的下标。
                k=next[k];
            if(B[k]==B[i])
                k+=1;
            next[i]=k;
        }
    }
    bool kmp(string &str,int lens,string &B,int lenb)
    {
        int* next=new int[lens];//new 类型[]!!!!!!;
        calnext(B,next,lenb);
        int k=0;
        for(int i=0;i<lens;++i)
        {
            while(k>0&&B[k]!=str[i])
                k=next[k];
            if(B[k]==str[i])
                k+=1;
            if(k==lenb)
                //return i-lenb+1;//开始匹配的位置
                return true;
        }
        return false;
    }

public:
    bool chkRotation(string A, int lena, string B, int lenb) {
        // write code here
        string str;
        str=A+A;
        return kmp(str,lena+lena,B,lenb);
        
    }
};

方法二.

使用暴力法求解是否存在字串

class Rotation {
public:
    bool strstr(string& str1, string& str2) {
        for (int i = 0; i < str1.length() - str2.length() + 1; ++i) {
            bool flag = true;
            int index = i;
            for (int j = 0; j < str2.length(); ++j,++index) {
                if (str1[index] != str2[j]) {
                    flag = false;
                    break;
                }
            }
            if (flag) return true;
        }
        return false;
    }

public:
    bool chkRotation(string A, int lena, string B, int lenb) {
     
        string str;
        str=A+A;
        return strstr(str,B);
        
    }
};

4.句子逆序

dog loves pig -> pig loves dog

class Reverse {
    public:
    void rev(string &str,int i ,int j)
    {
        while(i<j)
        {
            swap(str[i],str[j]);
            ++i;
            --j;
        }
    }
public:
    string reverseSentence(string A, int n) {
        
        int i=0,j=0;
        while(i<n)
        {
            while(j<n&&A[j]!=' ')
                ++j;
            rev(A,i,j-1);
            i=++j;
        }
            
        rev(A,0,A.size()-1);
        return A;
    }
};

5.字符串移位

ABCDE->DEABC

class Translation {
public:
    string stringTranslation(string A, int n, int len) {
        reverse(A.begin(),A.begin()+len);
        reverse(A.begin()+len,A.end());
        reverse(A.begin(),A.end());
        return A;
    }
};

6.拼接最小字典序

abc,ed -> abcde

class Prior {
public:
    string findSmallest(vector<string> strs, int n) {
        
        sort(strs.begin(),strs.end(),cmp);
        string result;
        for(auto i=strs.begin();i<strs.end();++i)
            result+=*i;
        return result;
    }
    static bool cmp(const string &first,const string &last)
    {
        return first+last<last+first?true:false;
    }
};

7.空格替换

class Replacement {
public:
    string replaceSpace(string iniString, int length) {
        int n=0;
        int i,j;
        for(i=0;i<length;i++){
            if(iniString[i]==' ')
                n++;
        }
        string s = iniString.append(2*n,'0');
        j = length+n*2-1;
        for(i=length-1;i>=0;i--){
            if(iniString[i]==' '){
                s[j--]='0';
                s[j--]='2';
                s[j--]='%';
            }
            else
                s[j--]=iniString[i];
        }
        return s;
    }
};

8.合法括号

方法一.

使用栈来实现

class Parenthesis {
public:
    bool chkParenthesis(string A, int n) {
       
        stack<char> st;
        for(auto c:A){
            if(c=='(')
                st.push(c);
            else if(c==')'){
                if(!st.empty() && st.top()=='(')
                    st.pop();
                else
                    return false;
            }
            else
            {
                if(st.empty())
                    return false;
                else
                    continue;
            }
        }
        if(st.empty())
            return true;
        return false;
    }
};

方法二

class Parenthesis {
public:
    bool chkParenthesis(string A, int n) {
        
        int t = 0;
        for(int i =0; i<n; i++)
        {
            if(A[i] == '(')
                t++;
            else if(A[i] == ')')
                t--;
            else
                continue;
            if(t < 0)
                return false;
        }
        if(t == 0) return true;
        return false;
    }
};

9.最长无重复子串

方法一

pre表示以A[i-1]结尾时的最大无重复子串所能到达的下标，即以A[i-1]结尾的最大无重复子串的长度为i-1-pre

class DistinctSubstring {
public:
    int longestSubstring(string A, int n) {
        
        int a[256];
        int pre=-1,cur=0,len=0;
         
        for(int i=0;i<256;i++)
            a[i]=-1;
         
        for(int i=0;i<n;i++)
        {
            pre=max(pre,a[A[i]]);
            cur=i-pre;
            len=max(cur,len);
            a[A[i]]=i;
        }
        return len;
    }
};

方法二

class DistinctSubstring {
public:
    int longestSubstring(string A, int n) {
        
        int ret = 0;  
        map<char, int> m;  
        int start = 1;  
        for (int i = 1; i <= A.length(); i++)  
        {  
            char c = A[i - 1];  
            if (m[c] >= start)  
            {  
                start = m[c] + 1;  
                m[c] = i;  
     
            }  
            else  
            {  
                m[c] = i;  
                ret = max(ret, i - start + 1);  
            }  
     
        }  
        return ret;  
                       
    }
};

方法三

暴力法，遇到重复字符则回溯。

class DistinctSubstring {
public:
    int longestSubstring(string A, int n) {
        
        map<char, int> ci;
        int cn = 0;
        int max = 0;
        for (int i = 0; i < A.length();) {
            auto find_it = ci.find(A[i]);
            if (find_it == ci.end()) {
                ++cn;
                ci[A[i]] = i;
                ++i;
            } else {
                i = find_it->second + 1;
                ci.clear();
                if (cn > max)
                    max = cn;
                cn = 0;
            }
        }
        return cn > max ? cn : max;
    }
};