c++简单入门训练

1.仅仅反转字母

原题目链接：仅仅反转字母

class Solution {
public:
    bool JudgeLetter(char& c)//判断是否为字母的接口函数
    {
        if((c>='a'&&c<='z')||(c>='A'&&c<='Z'))
        return true;
        else
        return false;
    }
    string reverseOnlyLetters(string s) {
        int start=0;//设置首指针
        int end=s.size()-1;//设置尾指针
        while(start<end)
        {
            while(start<end&&!JudgeLetter(s[start]))//找到字母为止
            ++start;
            while(start<end&&!JudgeLetter(s[end]))
            --end;
            char c=s[start];//交换字母
            s[start]=s[end];
            s[end]=c;
            start++;
            end--;
        }
        return s;
    }
};

知识点：
1.c++中引用的使用
2.string接口size（）含义：size（）是求string字符串的总的字母的个数
解题思路：
设置字符串的首尾指针，首指针从头向尾开始走，尾指针从尾向头开始走，将字符串的相对应的字母互相交换，如果遇到不是字母将跳过，直到首尾指针相遇就交换结束。

2.验证回文串

题目链接：验证回文串

	class Solution {
public:
    bool JudLetterAndNum(char& c)//判断是否为字母或者数字的接口函数
    {
        if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||(c>='0'&&c<='9'))
        return true;
        else
        return false;
    }
    bool isPalindrome(string s) {
    
        string:: iterator it=s.begin();//迭代器
        while(it!=s.end())
        {
            if(*it>='A'&&*it<='Z')//将大写字母变为小写字母
            {
                *it+=32;
            }
            it++;
        }
        int begin=0;//设置首指针
        int end=s.size()-1;//设置尾指针
        while(begin<=end)
        {
            while(begin<end&&!JudLetterAndNum(s[begin]))
            begin++;
            while(begin<end&&!JudLetterAndNum(s[end]))
            end--;
            if(s[begin]!=s[end])//如果不一样则，返回false
            return false;
            begin++;
            end--;
        }
        return true;
    }
};

知识点：
1.迭代器的定义;容器类名::iterator 迭代器名 ，使用时解引用*，++将正向迭代器向后走一步。
2.begin()和end（)返回的是首尾指针。

解题思路:
由于判断时，大写字母和小写字母是一样的，所以使用迭代器将字符串遍历一遍，将字符串中大写字母变为小写字母，然后设置首尾指针，首指针从头向尾开始走，尾指针从尾向头开始走，如果出现不一样的字符，则返回false，如果头尾、、首尾指针相遇时，没有出现不一样的字符，则返回true。

3.字符串中的第一个唯一字符

题目链接：字符串中的第一个唯一字符

class Solution {
public:
    int firstUniqChar(string s) {
        int cout[26]={0};//定义cout数组，数组中存储26个小写字母
        for(int i=0;i<s.size();i++)//对字符串遍历一遍
        {
            cout[s[i]-'a']++;//cout[s[i]-'a']相对应字母的个数
        }
        for(int i=0;i<s.size();i++)
        {
            if(cout[s[i]-'a']==1)
            return i;
        }
        return -1;
    }
};

解题思路：
先定义一个数组，这个数组能够储存26个小写字母，先对字符串遍历一遍，然后对每个字母进行计数，然后在遍历一遍，遇到第一个只有1的字母，就返回它的下标，如果没有，则返回-1.

对cout[s[i]-‘a’]的解释;首先cout数组中有26个整形变量，每个整形变量都为0，如果遇到字符‘a’，则为cout[0],cout[0]就++变为1，在遇到’a’，则为cout[0]就++变为2，如果遇到字符’b’，则为cout[1],cout[1]就++变为1，意思就是cout[0]代表的是a的字符串中字符的个数，cout[1]代表的是字符串中b的个数，cout[s[i]-‘a’]表示的是相对应字符的个数

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

题目链接：反转字符串中的单词 III

class Solution {
public:
   void reverse(string& s,int start,int end)
   {
       while(start<end)
       {
           char tmp=s[start];   
           s[start]=s[end];
           s[end]=tmp;
           start++;
           end--;
       }
   }
    string reverseWords(string s) {
        size_t start=0;
        size_t end=0;
        while(start<s.size())
        {
            end=s.find(' ',start);
            if(end!=string::npos)
            {
              reverse(s,start,end-1);
              start=end+1;
            }
           else
           {
             reverse(s,start,s.size()-1);
                return s;
           }
        }
        return s;
    }
};

知识点：
1.string中find（‘ ’，start）能够从start开始查找查找‘ ’的位置，如果查找不到则返回npos
2.size（）返回字符串中字符的个数

解题思路：
单词与单词之间是以空格相隔开来，所以我们可以定义start和end指针，start表示的是一个单词首字母的位置，end表示单词最后一个字母的位置，空格的上一个位置就是单词的end，空格下一个位置就是下一个单词的start，当最后一个单词时没有空格，所以找不到空格end等于npos，所以最后[start，size() ) 这个区间交换即可，并返回字符串。

5.反转字符串 II

题目链接反转字符串 II

class Solution {
public:
    void Reverse(string& s,int start,int end)
    {
        while(start<end)
        {
            char tmp=s[start];
            s[start]=s[end];
            s[end]=tmp;
            start++;
            end--;
        }
    }
    string reverseStr(string s, int k) {
       size_t start=0;
       size_t end=0;
        while(start<s.size())
        {
            end=start+k-1;
            if(end>=s.size())
            {
                Reverse(s,start,s.size()-1);
                return s;
            }
           Reverse(s,start,end);
           start=end+k+1;
        }
        return s;
    }
};

解题思路：
思路与上面那一道题是差不多的，只是start和end不大一样，还有如果最后的end大于等于字符串的size（），则在[start,size() )z中进行交换。

感谢你的点赞，收藏，关注！