c++ LeetCode (初级字符串篇) 九道算法例题代码详解（二）

原文作者：aircraft

原文链接：https://www.cnblogs.com/DOMLX/p/11089327.html

　　　　　　已经刷了很多篇leetcode题了，不过最近在找c++的实习工作（大佬们有推荐的吗QAQ），现在慢慢补上吧

　　　　　　虽然有点烦，但是还是要提一句，刷leetcode题目的时候，最好还是自己先思考然后写出一个通过的代码，再去看其他人的代码参考比较好，当然了，写不出来就当我没说。尽力而为即可。

一套面试题的目录在此，还在继续完善中。。。。。。

c/c++ 2019面试题目录

一、反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

我的代码：64ms左右

class Solution {
public:
    void reverseString(vector<char>& s) {
        int len = s.size();
        int i = ,j = len - ;
        while(i < j){
            s[i] = s[i]^s[j];
            s[j] = s[i]^s[j];
            s[i] = s[i]^s[j];

            i++;
            j--;
        }
    }
};

　　我的思路就是很简单的用两个i,j 一个由前向后移动，另外一个反之。这样就可以不断的把头尾字符串交换了，当i<j时就说明已经交换完毕了结束循环。

看看大佬们的代码：44ms左右

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

　　好吧，看来跟我的差别不是很大，就是调用了库函数交换，以及省略些判断过程。

二、整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

 示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2³¹,  2³¹ − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

我的代码：8ms左右

class Solution {
public:
    int reverse(int x) {
        int tem = ;
        if(x > ){
            while(x != ){

                if(tem > (INT_MAX - (x % )) /  )return ;
                tem = tem *  + x % ;
                x /= ;
            }
        }
        else{
            while(x != ){

                if(tem < (INT_MIN - (x % )) / )return ;
                tem = tem *  + x % ;
                x /= ;
            }

        }

        return tem;
    }
};

　　这道题的思路很简单，在大一学c语言的时候就遇到过将数字反转的测试题目，只要对X%10就能将其个位数字保留下来，然后tem = tem * 10 + x % 10; 就相当于将原来的末尾数保留下来，x /= 10; 已经拿到个位数了，那么就将原来的数除以10，将原来的十位数字移动到个位，这样组合起来就是每加入一个数就将上一个数值乘10加上后来的个位数字即可，

比如21----%10，就保留1，然后将21/10，并且因为是整型数据所以剩下2，然后2%10，还是2，tem = tem * 10 + x % 10;这样就是把1乘10+2，就将数字反转了。

　　不过这个跟大一的题目比较多了一个环境只能存储32 位的有符号整数，则其数值范围为 [−2³¹,  2³¹ − 1]。这其实就是有符号的Int型的存储范围，最大可以用内置的INT_MAX 表示，最小则是INT_MIN。

　　也就是说我们的环境是不予许出现超出这两个范围的数字的，那么我们一开始想的肯定是加一个判断--比如：tem * 10 + x % 10>INT_MAX就结束循环，或者tem * 10 + x % <INT_MIN,这个思路是没有问题的，不过在最后如果因为判断条件成立要结束这个循环的话，tem * 10 + x % 10 有些值必然会超过环境允许的范围，而报错，那么我们就换一个写法，数学的在大于小于符号左右移动数值的方法大家都学过吧。

我们只要将tem * 10 + x % 10>INT_MAX  变成  tem < (INT_MIN - (x % 10)) / 10 就不会在某一次判断的时候出现超过环境允许范围的数值了。

看看大佬们的代码：8ms左右

class Solution {
public:
    int reverse(int x) {
        int sum = ;
        for (; x != ; x /= ) {
            int yu = x % ;
            if (sum > (INT_MAX - yu) / ) return ;
            if (sum < (INT_MAX - yu) / ) return ;
            sum = sum *  + yu;
        }

        return sum;
    }
};

　　这个思路跟我一样，不过我一开始写的时候觉得需要对于正数负数需要分开判断，其实不需要，这样写就简化美观了很多。

大佬的代码：1ms左右

class Solution {
public:
    int reverse(int x) {
      if(x == ) return ;
        else
        {
            int flag = ;
            if(x > ) flag = ;
            else flag = -;
            long long l = abs((long long)(x));
            long long res = ;
            int ans;
            while(l > )
            {
                int temp = l % ;
                res  = res* + temp;
                l = l / ;
            }
            if(flag == ) ans =  res > INT_MAX ? :res;
            else  ans =  res*flag < INT_MIN ? :res*flag;
            return ans;
        }
    }
};

　　这个代码就是直接用64位的环境变量来存储，最后加一个判断，不过题目好像说只能在32的环境下吧，这个应该是为了刷速度写的。

三、字符串中的第一个唯一字符

 

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

案例:

s = "leetcode"
返回 0.

s = "loveleetcode",
返回 2.

注意事项：您可以假定该字符串只包含小写字母。

我的代码：80ms

class Solution {
public:
    int firstUniqChar(string s) {
        unordered_map<char,int> umap;
        int len = s.size();
        if(len == ) return ;
        for(auto s1:s){
            umap[s1]++;
        }
        for(int i = ; i < len; i++){
            if(umap[s[i]] == ) return i;
        }
        return -;
    }
};

　　我的思路就是将每个数字都存储起来然后计数，计数为1就是那一个字符了，不过呢，这样简单的东西我用了需要做很多特殊处理的unorder_map容器就比较花时间了，这个思路的还是用数组来存储会快上很多，比如下面的代码

20ms左右

class Solution {
public:
    int firstUniqChar(string s) {
         static const auto io_sync = []{
            std::ios::sync_with_stdio(false);
            std::cin.tie(nullptr);
            return nullptr;
        }();

        int times[]={};
        for(int i=;i<s.size();i++){
            times[s[i]-'a']++;
        }
        for(int i=;i<s.size();i++){
            if(times[s[i]-'a']==)
                return i;
        }
        return -;
    }
};

还有12ms大佬的代码：

class Solution {
public:
    int firstUniqChar(string s) {
        static const auto io_sync = []{
            std::ios::sync_with_stdio(false);
            std::cin.tie(nullptr);
            return nullptr;
        }();

        int num = , len = s.length();
        int a[] = {}, pos[] = {};
        char c[];
        for(int i = ; i < len; i++){
            if(a[s[i] - 'a'] == ){
                c[num++] = s[i];
                pos[s[i] - 'a'] = i;
            }
            a[s[i] - 'a']++;
        }
        for(int i = ; i < num; i++){
            if(a[c[i] - 'a'] == ){
                return pos[c[i] - 'a'];
            }
        }
        return -;
    }
};

　　这个就是将前面那个20ms的代码优化了一下，我们从string类型中拿数据的话要比从一个char数组里拿数据要做的工作会多很多。

四、有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

说明:
你可以假设字符串只包含小写字母。

进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

我的代码：16ms左右

class Solution {
public:
    bool isAnagram(string s, string t) {
        unordered_map<char,int> umap_s,umap_t;
        int len_s = s.size();
        int len_t = t.size();
        if(len_s != len_t) return false;
        for(int i = ; i < len_s; i++){
            umap_s[s[i]]++;
            umap_t[t[i]]++;
        }
        for(auto ch:umap_s){
            if(umap_s[ch.first] != umap_t[ch.first]) return false;
        }
        return true;
    }
};

　　就是像unordered_map以及map类的容器真的是非常的好用，在一些局部代码或者是小型项目，对速度的需要没有确切需求的地方都可以很好的使用。

　　我的思路就是用两个容器分别存储，然后计数，如果双方某一个字符的计数值不同，那么肯定不是异位字符串了。

　　但是我们其实用char或者int类型的数组来操作就可以做到了，并且速度优化很多。

大佬们的代码：1ms左右

class Solution {
public:
    bool isAnagram(string s, string t) {
        //字母异位词，指的是字母相同，排列不同的单词
        if (s.size() != t.size()) return false;
        int m[] = {};

        for (int i = ; i < s.size(); ++i) ++m[s[i] - 'a'];
        for (int i = ; i < t.size(); ++i){
            if (--m[t[i]-'a'] < ) return false;
        }

        return true;
    }
};

　　这个代码就简化了很多，并且提高的速度，直接用一个int型的数组存储第一个字符串的-‘a'之后的ASCII的值，其他没出现的都置为0，然后第二个for循环就是把第二个字符串的数值都拿去跟第一个通过相减的方式比对，因为你有一个，我也有 一个那么减后就是为0，而如果我有你没有，那么减后就会小于0，这样判断是有大前提的s.size() != t.size()，两个的size是相同的。

五、验证回文字符串

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

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true

示例 2:

输入: "race a car"
输出: false

我的代码：20ms

class Solution {
public:
    bool isPalindrome(string s) {
        int len = s.size();
        if(len == ) return true;
        int i = ,j = len - ;
        while(i < j){
            if(s[i] >= '' && s[i] <= '' || s[i] >= 'A' && s[i] <= 'Z' || s[i] >= 'a' && s[i] <= 'z');
            else{
                i++;
                continue;
            }
            if(s[j] >= '' && s[j] <= '' || s[j] >= 'A' && s[j] <= 'Z' || s[j] >= 'a' && s[j] <= 'z');
            else{
                j--;
                continue;
            }
            if(s[i] >= 'a' || s[j] >= 'a'){
                if(abs(s[i] - s[j]) ==  || abs(s[i] - s[j]) == ){
                    i++;
                    j--;
                }
                else return false;
            }
            else if(abs(s[i] - s[j]) == ){
                i++;
                j--;
            }
            else return false;

        }
        return true;
    }
};

　　我的思路就是忽略掉大小写的影响，以及不属于数字或者字符的影响，剩下的用两个指针来移动对比，一个头指针，一个尾，如果有一个比对不成立，那么就不是回文字符串，这个代码有很多可以优化的地方，比如判断是字符或者数字，都可以直接使用库函数，然后题目说忽略大小写的影响，那么干脆把所有字符串都换成大写或者小写在来比对好了。。。。反正当时我是没有想到用库函数，都是自己写了。

大佬们的代码：1ms左右

class Solution {
public:
    bool isPalindrome(string s) {
        int lefts=;
        int rights=s.size()-;
        while(lefts<rights)
        {
            while(!isalnum(s[lefts]))
            {
                lefts++;
                if(lefts>=rights)
                    return true;
            }
            while(!isalnum(s[rights]))
            {
                rights--;
                if(lefts>rights)
                    return false;
            }
            if(tolower(s[lefts])!=tolower(s[rights]))
                return false;
            lefts++;
            rights--;
        }
        return true;
    }
};

　　这个代码就是一个外循环来遍历，而里面的两个while则是用来分别跳过左边不是数字或者字符的数，然后在将左边的值与右边的值都转为小写比对，若是不相同那么就不是回文字符串了。

isalnum（）用来判断字符或者数字，tolower（）转为小写。

六、字符串转整数

请你来实现一个 atoi 函数，使其能将字符串转换成整数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。

当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。

该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。

注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0。

说明：

假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−2³¹,  2³¹ − 1]。如果数值超过这个范围，qing返回  INT_MAX (2³¹ − 1) 或 INT_MIN (−2³¹) 。

示例 1:

输入: "42"
输出: 42

示例 2:

输入: "   -42"
输出: -42
解释: 第一个非空白字符为 '-', 它是一个负号。
     我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。

示例 3:

输入: "4193 with words"
输出: 4193
解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。

示例 4:

输入: "words and 987"
输出: 0
解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
     因此无法执行有效的转换。

示例 5:

输入: "-91283472332"
输出: -2147483648
解释: 数字 "-91283472332" 超过 32 位有符号整数范围。
     因此返回 INT_MIN (−2

³¹

) 。

我的代码：8ms左右

class Solution {
public:
    int myAtoi(string str) {
        int sign = ,res = ,i = -,len = str.size();
        if(len < ) return ;
        while(i < len && str[++i] == ' ');
        if(i >= len) return ;
        if(str[i] == '-'){
            sign = -;
            i++;
        }
        else if(str[i] == '+') i++;

        if(sign != -){
            while(str[i] >= '' && str[i] <= ''){
                if(res > ((INT_MAX - (str[i] - '')) / )) return INT_MAX;
                res = res *  + (str[i]-'');
                i++;
            }
            return res;
        }
        while(str[i] >= '' && str[i] <= ''){
                if(-res < ((INT_MIN + (str[i] - '') ) / ) ) return INT_MIN;
                if(res *  > (INT_MAX -(str[i] - '')) ){
                    return -res *  - (str[i]-'');
                }
                res = res *  + (str[i]-'');
                i++;
            }
        return -res;

    }
};

　　字符串转数字这个代码应该初学c语言的时候大家都学过，而这个题目就是加一个限制，环境只能容纳32位有符号整型的值。所以要多加点判断。

　　字符串转数字无非就是res * 10 + (str[i]-'0'); 将字符的值-‘0’的值，然后如果刚转的这个数前面已经有数字存在了，那么就把前面的那个高位数乘10提高一个位数加上去就行了。

　　 而要加判断的话，大于0的值比较，一般是这样的想法：res * 10 + (str[i]-'0');>INT_MAX就不成立，然而环境不允许存在比INT_MAX大的值，那么我们就移动一下比较符号左右的运算，变成这样：

　　res > ((INT_MAX - (str[i] - '0')) / 10)；这样的预判式子就不会突破环境变量的限制了。

小于0的话就这样改：-res < ((INT_MIN + (str[i] - '0') ) / 10)；

大佬们的代码：1ms左右

class Solution {
public:
    int myAtoi(string str) {
        int cur = ;
        int len = str.length();
        int flag = ;
        int ret = ;
        while(cur < len && str[cur]==' ')
        {
            cur ++;
        }
        if(cur ==len)
            return ;
        else if(str[cur]=='-')
            flag = -;
        else if(str[cur]=='+')
            flag = ;
        else if(isdigit(str[cur]))
            ret = str[cur] -'';
        else
            return ;

        cur +=;
        while(cur < len && isdigit(str[cur]))
        {
            int temp = (str[cur] -'') * flag;
            if (ret > INT_MAX /  || ret == INT_MAX /  && temp > )
                return INT_MAX;
            if (ret < INT_MIN /  || ret == INT_MIN /  && temp < -)
                return INT_MIN;
            ret =ret * + temp;
            cur ++;
        }
        return ret;
    }
};

　　这个代码就比我的优化很多了，我的分别把正负值分开算，多了很多代码和判断，而这里直接放在一个循环里，通过flag来确定符号就挺好的。

七、实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回  -1。

示例 1:

输入: haystack = "hello", needle = "ll"
输出: 2

示例 2:

输入: haystack = "aaaaa", needle = "bba"
输出: -1

说明:

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

我的代码：4ms

class Solution {
public:
    int strStr(string haystack, string needle) {
        int ht_len = haystack.size();
        int nl_len = needle.size();
        int len = ht_len - nl_len;
        int i, j = ;
        if(nl_len == ) return ;
        for(i = ; i <=len; i++){
            if(haystack[i] == needle[j]){
                while(j < nl_len && haystack[i + j] == needle[j]) j++;
                if(j == nl_len) return i;
                j = ;
            }
        }
        return -;

    }
};

　　我的思路就是：从第一个字符串中找第二个子串出现的位置，那么只要从第一个串里面找到第二个子串相匹配的字符，然后记住位置，遍历一个子串长度的数据对比，都相同的话就代表找到了。

　　同样的，假如第二个字符串长度为3，第一个为6，那么第一个字符串到第四个位置之后就没有必要再去比较判断了，所以真正可以比较长度就是len1 - len2的长度。

大佬们的代码：1ms左右

class Solution {
    int issame(string haystack, string needle,int k)
    {
        if(haystack.length()-k<needle.length())
            return -;
        for(int i=;i<needle.length();i++)
        {
            if(haystack[i+k]!=needle[i])
                return issame(haystack,needle,k+);
        }

        return k;
    }
public:
    int strStr(string haystack, string needle) {
        if(needle=="")
            return ;
        return issame(haystack,needle,);
    }
};

　　这个大佬用递归的方法不断的递归寻找到第二串的第一个字符在第一个串出现的位置，找到后就遍历比对，若不成立则继续递归并且增加k值，直到k值不满足haystack.length()-k<needle.length()这个条件就说明不存在，返回-1.利用了空间换时间的方法，增加了速度，而且编程之美里面说过，“迭代是人，递归为神”，能用递归的方法会使得代码更加简洁和快速，不过要注意堆栈的溢出问题就是了。

八、报数

报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：

1.     1
2.     11
3.     21
4.     1211
5.     111221

1 被读作  "one 1"  ("一个一") , 即 11。
11 被读作 "two 1s" ("两个一"）, 即 21。
21 被读作 "one 2",  "one 1" （"一个二" ,  "一个一") , 即 1211。

给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。

注意：整数顺序将表示为一个字符串。

示例 1:

输入: 1
输出: "1"

示例 2:

输入: 4
输出: "1211"

我的代码：8ms左右

class Solution {
public:
    string countAndSay(int n) {
        vector<string> list;
        int len;
        int j = ;
        int count = ;
        string temp = "";
        string ch = "";
        list.emplace_back("");
        for (int i = ; i < n; i++) {
            len = list[i - ].size();
            while (j < len) {
                ch = list[i - ][j];
                if (j == (len - )) {
                    temp += "" + ch;
                    break;
                }
                while (j < len - 1 && list[i - ][j] == list[i - ][j + ]) {
                    count += ;
                    j++;
                }
                temp += to_string(count) + ch;
                count = ;
                j++;
            }
            list.emplace_back(temp);
            temp = "";
            j = ;
        }
        return list[n - ];
    }
};

　　这题理解题目的意思就比较重要了，一开始我没理解写了很多都通过不了，自己也找不到原因。后来是删除了所有代码重新思考了一遍才写出来。

　　反正就是下一个数就是把上一个数字按照一定语法来解读，比如1211后面的111221，因为1211是先一个1 所以为11，然后是一个2 所以为 12，然后两个1 为21，全部组合起来就是111221，是这么个意思，所以我们就用上一个不断的去推出下一个，这就是一个迭代过程。

　　那我们只需要纪录下第一个字符，然后计算有几个一样的写上就好，遇到不一样的在替换纪录的字符继续计数，比如1112，三个1=31，替换为2，有一个2=12  组合起来就是3112

　

看看大佬们的代码：1ms左右

class Solution {
public:
    string countAndSay(int n) {
        string str = "";
        if(n == ) return str;
        for(int i = ; i <= n; ++i)
        {
            string tmp = "";
            char cur = str[];
            int cnt = ;
            for(int j = ; j < str.length(); ++j)
            {
                if(str[j] != cur)
                {
                    tmp.push_back(char(cnt+''));
                    tmp.push_back(cur);
                    cur = str[j];
                    cnt = ;
                }
                else ++cnt;
            }
            tmp.push_back(char(cnt+''));
            tmp.push_back(cur);
            str = tmp;
        }
        return str;
    }
};

　　大佬的思路跟我差不多，不过写法比我优化很多。

九、最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"

示例 2:

输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。

说明:

所有输入只包含小写字母 a-z 。

我的代码：20ms

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if(strs.empty()) return "";
        int len = INT_MAX;
        string temp;
        for(auto str:strs){
            if(str.size() < len) len = str.size();
        }
        for(int i = ; i < len; i++){
            temp = strs[].substr(,i + );
            for(auto str:strs){
                if(str.substr(,i + ).find(temp) == str.npos) return strs[].substr(,i);
            }
        }
        return strs[].substr(,len);
    }
};

　　题目的意思很清楚，也不需要什么思路就是比较就是了，我的是一次把多个字符切割好去比较，直到最后一次比较不成功，之前的就是最长公共前缀，这样看起来代码很清楚，不过效率特别慢，因为中间做了很多很多事。

大佬们的代码：1ms左右

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        string res;
        int n=strs.size();
        if(n==)
            return res;
        else if(n==)
            return strs[];
        char c;
        for(int i=;;i++){
            c=strs[][i];
            for(int j=;j<n;j++){
                if(c=='\0'||strs[j][i]!=c)
                    return res;
            }
            res+=c;
        }
        return res;
    }
};

　　一个个字符去遍历比较，都有的话就加到结果里，最后返回的就是最长公共前缀了。

后面还是会陆续更新leetcode算法篇，也有其他面试教程篇或者网络编程篇之类的。想要的话就关注我把！！！！感谢各位。

若有兴趣交流分享技术，可关注本人公众号，里面会不定期的分享各种编程教程，和共享源码，诸如研究分享关于c/c++,python,前端，后端，opencv,halcon,opengl,机器学习深度学习之类有关于基础编程，图像处理和机器视觉开发的知识