小白刷题入门Leetcode（二）——字符串 C++

最新推荐文章于 2024-08-15 05:02:54 发布

www_z_dd

最新推荐文章于 2024-08-15 05:02:54 发布

阅读量250

点赞数 2

文章标签： c++

本文链接：https://blog.csdn.net/www_z_dd/article/details/104851777

版权

字符串

28. 实现 strStr()

解法一：直接用string.fin()函数，只要把返回值不找到的情况搞定就可以。Find函数不找到返回str.npos 这里改成-1就可以。
这是用语言的内置函数。接下来是别的不用内置函数的实现。

class Solution {
public:
    int strStr(string haystack, string needle) {
        int position=haystack.find(needle); 
        if(position==haystack.npos)return -1;
        else return position;        
    }
};

解法二：双指针法
用两个指针，如果匹配，两个指针就都向右移动，比较下一个字符。如果不匹配, needle的指针重新指向开始，haystack的指针指向刚才的位置加1；所以用一个start来记录每次比较的开始位置；
如果用equal函数来比较，每次比较长度为needle.size()的长度，如果一个字符一个字符的比较，就不需要了；

int strStr(string haystack, string needle) {
    if (needle.empty())return 0;
    if (haystack.empty())return -1;
    int p = 0, q = 0;
    int start = 0;
    while (start < haystack.size())
    {
        for (p = start, q = 0; q < needle.size() && p < haystack.size() ; p++, q++)
        {
            if (!(haystack[p] == needle[q])) break;
            if(q== needle.size()-1)return start;
        }
        start++;
    }
    return -1;
}

答案里的另一种方法：

class Solution {
public:
    int strStr(string haystack, string needle) {
        if (needle.length() == 0) {
            return 0;
        }
        int len = haystack.length();
        int nlen = needle.length();
        if (len < nlen) {
            return -1;
        }
        int j = 0;
        for (int i = 0; i < len;) {
            if (haystack[i++] == needle[j]) {
                j++;
            } else {
                if (j > 0) {
                    i = i - j;
                    j = 0;
                }
            }
            if (j == nlen) {
                return i - j;
            }
        }
        return -1;
    }
};

3.8 外观数列

方法一：迭代
用迭代的方法来做，怎么把这些东西都输出来呢。一开始n=1得到的是一个为1的字符串，然后n为2时，就把连续的数字数出来，num记录读到的数字，times记录次数，第一个字符给num，然后times++，然后与下一个比较。如果相同就指针右移，times++；如果不相同，就把这一组num和times写进字符串中，把这个字符的值更新给num和times。
直到迭代到了。
这样需要一个新的字符串来保存结果。
在简单的题目里面算是比较难的类型，对string的一些方法的掌握比如to_string()

  string countAndSay(int n) {
        string str1, str2;
        str1 = "1";
        if (n == 1)return str1;
        int i = 1;//用来记录迭代的次数，直到n-1
        int  times=0, j=0;
        char num;
        for (i = 1; i < n; i++)
        {
            
            for (j = 0; j < str1.size(); j++)
            {
                if (j == 0)
                {
                    num = str1[j];
                    times = 1;
                }
                else {
                    if (str1[j] == num) times++;
                    else {
                        str2+=to_string(times);
                        str2 +=num;
                        num = str1[j];
                        times = 1;
                    }
                }

            }
            str2 += to_string(times);
            str2 += num;
            str1.swap(str2);
            str2.clear();


        }
        return str1;

    }

方法二：看了柳婼https://www.liuchuo.net/archives/4646的博客我觉得这确实是一个简单题了。

思路大致和上述一致。但是为什么不需要清空字符串T的值呢。

#include <iostream>
using namespace std;
int main() {
    string s;
    int n, j;
    cin >> s >> n;
    for (int cnt = 1; cnt < n; cnt++) {
        string t; //每次运行到了这句话T都会变成了空
        for (int i = 0; i < s.length(); i = j) {
            for (j = i; j < s.length() && s[j] == s[i]; j++);
            t += s[i] + to_string(j - i);
        }
        s = t;
    }
    cout << s;
    return 0;
}

58. 最后一个单词的长度

这个题目的坑在于，可能是一个空格的测试用例，也有可能是末尾一个空格，也有可能是末尾很多空格。
所以我选择一开始就去除尾巴的空格。
解法一：
第一个循环遍历这个字符串。第二个for循环找到一个由空格结束的字串。I记录的其实就是每一个单词的首地址。
内层循环是为了找到单词的尾巴索引。相减就是要得到的字符串大小。

class Solution {
public:
int lengthOfLastWord(string s) {
for (int k = s.size() - 1; k >= 0&& s[k] == ' '; k--) s.pop_back();
    if (s.empty())return 0;
    int j;
    for (int i = 0; i <=s.size(); i=j+1) {
        string t;
        for (j = i; j < s.size()&& s[j] != ' '; j++)  t += s[j];
        if (j == s.size())return j-i;      
        }
        return 666;
    }
};

方法二：
从末尾开始判断，找到一个不是空格的字符。然后计算这个单词的大小。

class Solution {
public:
int lengthOfLastWord(string s) {
    for (int k = s.size() - 1; k >= 0&& s[k] == ' '; k--) s.pop_back();
    if (s.empty())return 0;
    int i = 0;
    for ( i = s.size() - 1; i >= 0 && s[i] != ' '; i--);
    return s.size() - i - 1;
    }
};

方法三：
也是从末尾开始找，但是多了一个变量count；在循环中，如果找到了非空格值就count++
否则的话，如果count为空说明还没找到倒数第一个单词，继续往前找。
Count不为空说明这是最后一个单词。

class Solution {
public:
int lengthOfLastWord(string s) {
   int count=0;
   for(int i=s.size()-1;i>=0;i--)
       if(s[i]!=' ')count++;
       else   if(count)return count;
    return count;
    }
};

67. 二进制求和

注意字符和数字相加减得到的值不同。
方法一：
从尾巴开始相加，考虑到两个串位数不同的情况，用加数num1, num2表示当前的数值。如果一个串遍历完了，就设为0；
然后加数对2的余数放在结果串的开头，设置进位；
最后注意两个串都到头了，如果进位不是0，也要进位在最前面；

class Solution {
public:
    string addBinary(string a, string b) {
        int i = a.size() - 1, j = b.size() - 1,k=0;
        string re;
        int carry = 0;
        int sum = 0;
        int num1 = 0, num2 = 0;
        for (; i >=0 || j >= 0; i--,j--) {
            if (i < 0)num1 = '0';
            else num1 = a[i];
            if (j < 0)num2 = '0';
            else num2 = b[j];
            sum = num1 + num2 + carry-2*'0';
            re.insert(0, to_string(sum % 2));
            carry = sum / 2;

        }
        if (carry) re.insert(0, to_string(carry));
        return re;

    }
};

方法二：
法一的用时比较久，另一种用时最短的算法是位运算。

但是我不会位运算。

用时第二少的算法是没有太多的加减运算判断是01 00 10 11这几种情况。不使用除法和取余运算，所以设置carry表示进位。

class Solution {
public:
    string addBinary(string a, string b) {
        int k=0;
        string re;
        bool carry = false;
        char ca, cb;
        for (int i = a.size() - 1, j = b.size() - 1; i >= 0 || j >= 0; i--, j--) {
            if (i < 0) ca = '0';
            else ca = a[i];
            if (j < 0)cb = '0';
            else cb = b[j];
            int p = 0;
            if (carry) {
                p++;
                carry = false;
            }
            if ((ca == '0' && cb == '1') || (ca == '1' && cb == '0'))p++;
            if ((ca == '1' && cb == '1'))p += 2;
            if (p > 1) {
                carry = true;
                if (p == 2)p = 0;
                else p=1;
            }
            re.insert(0, to_string(p));
        }
        if(carry) re.insert(0,"1");
        return re;
    }
};

125. 验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

解法一：
头尾两个索引，分别找到第一个字母或者数字；然后比较，如果不相等就可以直接返回了。如果相等的话，就要下一步比较。
退出循环的条件是两个指针相遇；

#include<algorithm>
class Solution {
public:
    bool isPalindrome(string s) {
        if(s.size()<2)return true;        
        transform(s.begin(), s.end(), s.begin(), ::tolower);
        for(int i=0, j=s.size()-1;i<j;i++,j--){
            for(;i<j&&!(s[i]>='a'&&s[i]<='z')&&!(s[i]>='0'&&s[i]<='9');i++)cout<<i<<endl;
            for(;i<j&&!(s[j]>='a'&&s[j]<='z')&&!(s[j]>='0'&&s[j]<='9');j--)cout<<j<<endl;
            if(s[i]!=s[j])return false;            
        }
        return true;
    }
};

解法二：
改进一下，使用C++的isalnum（）函数。
transform一次把一整个字符串改为大写或者小写。tolower()一次改一个字符；

#include<algorithm>
class Solution {
public:
    bool isPalindrome(string s) {
        for(int i=0, j=s.size()-1;i<j;i++,j--){
            for(;!isalnum(s[i])&&i<j;i++)cout<<i<<endl;
            for(;!isalnum(s[j])&&i<j;j--)cout<<j<<endl;
            if(tolower(s[i])!=tolower(s[j]))return false;            
        }
        return true;
    }
};

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。你可以假设数组中的所有字符都是 ASCII
码表中的可打印字符。

解法一：
两个索引分别指向头和尾巴，然后这两个位置的字符交换。直到这两个索引相遇；

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

解法二：
不用第二个索引了，循环跳出的条件变为i<=N/2, 与N-i-1位置的字符进行交换。这样处理速度是最快的；

class Solution {
public:
    void reverseString(vector<char>& s) {
        int n=s.size();
        for(int i=0; i<n/2;  i++){
            char c=s[i];
            s[i]=s[n-i-1];
            s[n-i-1]=c;
        }        
    }
};

解法三：
Swap（）函数

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

一行搞定；

434. 字符串中的单词数

方法一：
跳过所有的空格，连在一起的字符记作一个单词；

class Solution {
public:
    int countSegments(string s) {
        int count=0;
        for(int i=0;i<s.size();){
            while(s[i]==' '&&i<s.size())i++;
            if(i==s.size())return count;
            for(;s[i]!=' '&&i<s.size();i++);
            count++;
        }
        return count;
    }
};

方法二：
一个字符并且后面有一个空格的情况，是一个单词；
所以一开始在尾巴加一个空格；

class Solution {
public:
    int countSegments(string s) {
        int count=0;
        s+=' ';
        for(int i=0;i< s.size()-1;i++)
            if(s[i]!=' '&&s[i+1]==' ')count++;
        return count;
    }
};

方法三：
用用stringstream。

class Solution {
public:
    int countSegments(string s) {
        int count=0;
        string ss;
        stringstream sss(s);
        for(;sss>>ss;count++);
        return count;
    }
};

在stringstream类中，构造字符串流时，空格会成为字符串参数的内部分界；

www_z_dd

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
小白刷题入门Leetcode（二）——字符串 C++

**2 字符串**28. 实现 strStr()解法一：直接用string.fin()函数，只要把返回值不找到的情况搞定就可以。Find函数不找到返回str.npos 这里改成-1就可以。这是用语言的内置函数。接下来是别的不用内置函数的实现。class Solution {public: int strStr(string haystack, string needle) {...
复制链接

扫一扫