【题解】《算法零基础100讲》(第25讲) 字符串算法(五) - 字符串反转

344. 反转字符串

reverse

看到这道题的名字就一个念头，reverse…

class Solution {
public:
    void reverseString(vector<char>& s) {
        reverse(s.begin(),s.end());
    }
};

双指针

这毕竟不是出题人的念头…那么我们来想想正确的思路
反转一个字符串就是把第一个字符和倒数第一个字符交换，第二个字符和倒数第二个字符交换…依次进行

class Solution {
public:
    void reverseString(vector<char>& s) {
        int i=0,j=s.size()-1;
        while(i<j)
        {
            swap(s[i],s[j]);
            i++,j--;
        }
    }
};

2000. 反转单词前缀

线性枚举+双指针

交换方式和上一道题一样，和上一道题不一样的就是交换的右端点。线性枚举找到所找的位置。

class Solution {
public:
    string reversePrefix(string word, char ch) {
        int l=0,r=-1;
        for(int i=0;i<word.size();i++)
            if(word[i]==ch) 
            {
                r=i;
                break;
            }
        while(l<r)
        {
            swap(word[l],word[r]);
            l++,r--;
        }
        return word;
    }
};

345. 反转字符串中的元音字母

线性枚举+双指针

交换的方式还是和第一题相同，只需要线性枚举出所有元音字母的位置存到一个数组中，然后交换时候只交换数组中的下标

class Solution {
public:
    string reverseVowels(string s) {
        vector<int>res;
        for(int i=0;i<s.size();i++)
        {
            if(s[i]=='a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=='u'||s[i]=='A'||s[i]=='E'||s[i]=='I'||s[i]=='O'||s[i]=='U') res.push_back(i);
        }
        int i=0,j=res.size()-1;
        while(i<j)
        {
            swap(s[res[i]],s[res[j]]);
            i++,j--;
        }
        return s;
    }
};

剑指 Offer 58 - I. 翻转单词顺序

线性枚举+双指针

线性枚举找出所有的单词，然后交换他们的位置

class Solution {
public:
    string reverseWords(string s) {
        vector<string>res;
        string ch;
        s+=' ';
        for(int i=0;i<s.size();i++)
        {
            if(s[i]!=' ') ch+=s[i];
            else
            {
                if(ch.size()) res.push_back(ch);
                ch.clear();
            }
        }
        int i=0,j=res.size()-1;
        while(i<j)
        {
            swap(res[i],res[j]);
            i++,j--;
        }
        string ans;
        for(auto t:res) ans+=t+' ';
        return ans.substr(0,ans.size()-1);
    }
};

557. 反转字符串中的单词 III

线性枚举+双指针

给首尾加一个空格减少对首首尾的控制。线性枚举发现他是一个单词以后进行双指针实现的交换操作

class Solution {
public:
    string reverseWords(string s) {
        int l,r;
        s=' '+s+' ';
        for(int i=0;i<s.size();i++)
        {
            if(i!=0&&s[i]==' ')
            {
                l=r+2,r=i-1;
                int g=l,h=r;
                while(g<h)
                {
                    swap(s[g],s[h]);
                    g++,h--;
                }
            } 
            else if(s[i]==' ') l=r=i-1;
            
        }
        return s.substr(1,s.size()-2);
    }
};

541. 反转字符串 II

线性枚举+双指针

枚举到2k的倍数是就反转前k个字符

class Solution {
public:
    string reverseStr(string s, int k) {
        int cnt=0;
        for(int i=0;i<s.size();i++)
        {
            cnt++;
            if(cnt%(2*k)==0)
            {
                int l=cnt-2*k,r=cnt-k-1;
                while(l<r)
                {
                    swap(s[l],s[r]);
                    l++,r--;
                }
            }
        }
        if(s.size()%(2*k))
        {
            int g=s.size()/(2*k)*2*k;
            if(s.size()-g<k)
            {
                int l=g,r=s.size()-1;
                while(l<r)
                {
                    swap(s[l],s[r]);
                    l++,r--;
                }
            }
            else 
            {
                int l=g,r=g+k-1;
                while(l<r)
                {
                    swap(s[l],s[r]);
                    l++,r--;
                }
            }
        }
        return s;
    }
};

917. 仅仅反转字母

线性枚举+双指针

线性枚举分开是字母和不是字母的部分，反转是字母的部分，然后在应该不是字母添加符号

class Solution {
public:
    string reverseOnlyLetters(string s) {
        int cnt=0,flag=0,g=0,st=0;
        string ch,ans;
        vector<int>res,fu;
        for(int i=0;i<s.size();i++)
        {
            if(s[i]>='a'&&s[i]<='z'||s[i]>='A'&&s[i]<='Z') cnt++,ch+=s[i];
            else 
            {
                res.push_back(cnt);
                fu.push_back(s[i]);
                cnt=0;
            }
        }
        int l=0,r=ch.size()-1;
        while(l<r)
        {
            swap(ch[l],ch[r]);
            l++,r--;
        }
        res.push_back(0x3f3f3f3f);
        for(int i=0;i<ch.size();i++)
        {
            while(g==res[flag]) 
            {
                if(flag<res.size()-1) flag++;
                ans+=fu[st++]; 
                g=0;
            }
            ans+=ch[i];
            g++;
        }
        for(int i=st;i<fu.size();i++) ans+=fu[i];
        return ans;
    }
};

7. 整数反转

取数位

直接把整数的每一位取出来，从后往前加入数组中，然后求出现在数组表示的数

class Solution {
public:
    int reverse(int x) {
        int k=1;
        long res=x;
        if(res<0) res=-res,k=-1;
        vector<int>num;
        while(res)
        {
            int t=res%10;
            num.push_back(t);
            res/=10;
        }
        long ans=0;
        for(int i=0;i<num.size();i++)
        {
            ans=ans*10+num[i];
        }
        if(ans<=((1ll<<31)-1)&&ans>=-(1ll<<31))return ans*k;
        return 0;
    }
};