【LeetCode初级算法】字符串篇

最新推荐文章于 2022-10-03 21:59:54 发布

原创最新推荐文章于 2022-10-03 21:59:54 发布 · 473 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

4 篇文章

订阅专栏

本文详细解析了LeetCode中关于字符串的初级算法题目，包括反转字符串、整数反转、找到字符串的第一个唯一字符、验证字母异位词、回文字符串验证、字符串转换整数、实现strStr函数、外观数列和最长公共前缀。通过实例和多种解法介绍，帮助读者理解和掌握这些基础算法。

反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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”]

…
函数编程法

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

整数反转

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

示例 1:

输入: 123 输出: 321 示例 2:

输入: -123 输出: -321 示例 3:

输入: 120 输出: 21 注意:

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

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

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

案例:

s = “leetcode” 返回 0.

s = “loveleetcode”, 返回 2.

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

哈希表思路，26个位置的数组，遍历两次即可。

class Solution {
public:
    int firstUniqChar(string s) {
        int letters[26] = {};
        for(int i = 0; i < s.size() ;++i){
            letters[(int)(s[i]-'a')]++;
        }
        for(int i = 0; i < s.size() ;++i){
            if(letters[(int)(s[i]-'a')] == 1)
                return i;
        }
        return -1;
    }
};

有效的字母异位词

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

示例 1:

输入: s = “anagram”, t = “nagaram” 输出: true 示例 2:

输入: s = “rat”, t = “car” 输出: false 说明: 你可以假设字符串只包含小写字母。

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

使用一个map，遍历一次将两个字符串往里放，s放入的时候对应的value值++，t放入时–，最后遍历一次map，如果所有的value为0说明s和t是字母异位词。

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size()!=t.size())
            return false;
        map<char,int> help;
        for(int i = 0; i < s.size();++i){
            if(help.find(s[i])==help.end())
                help.insert(make_pair(s[i],1));
            else
                help[s[i]]++;
            if(help.find(t[i])==help.end())
                help.insert(make_pair(t[i],-1));
            else
                help[t[i]]--;
        }
        auto it = help.begin();
        while(it!=help.end()){
            if(it->second!=0)
                return false;
            it++;
        }
        return true;
    }
};

验证回文字符串

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

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

示例 1:

输入: “A man, a plan, a canal: Panama” 输出: true 示例 2:

输入: “race a car” 输出: false

两根指针分别从头和尾开始移动，逐位对比是否相等。

class Solution {
public:
bool isPalindrome(string s) {
        if(s.size() == 0) return true;
        int low = 0;
        int high = s.size()-1;
        while(low < high)
        {
            while(low < high && !isAlphanum(s[low]))
            {//从前往后遍历，既不是字母又不数字，则略过
                low++;
            }
            while(low < high && !isAlphanum(s[high]))
            {//从后往前遍历，既不是字母又不数字，则略过
                high--;
            }//tolower()函数实现将大写转换为小写字母
            if(tolower(s[low]) != tolower(s[high]))
            {//如果对称位置的不相等
                return false;
            }
            low++;
            high--;
        }
        return true;
    }
    bool isAlphanum(char c)
    {
        return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9');
    }
};

字符串转换整数 (atoi)

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

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

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

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

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

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

说明：

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

示例 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 (−231) 。

我就是硬抠各种边界解出来的。

class Solution {
public:
    int myAtoi(string str) {
        if(str.empty())
            return 0;
        int i = 0;
        while(str[i] == ' ')
            str = str.substr(1);
        bool sign = true;
        if(str[i]=='-'||str[i]=='+'){
            if(str[i]=='-')
                sign = false;
            str = str.substr(1);
        }
        int res=0;
        while(str[i]>='0'&&str[i]<='9')
        {
            if(res > INT_MAX/10 || (res == INT_MAX/10 && (int)(str[i]-'0')>=8)){
                if(sign)
                    return INT_MAX;
                else
                    return INT_MIN;
            }
            res = res*10 + (int)(str[i]-'0');
            i++;
        }
        if(i==0)
            return 0;
        if(sign)
            return res;
        else
            return -res;         
    }
};

实现 strStr()

实现 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()
定义相符。

有点难懂 KMP，日后再搞

外观数列

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。前五项如下：
1
11
21
1211
111221 1 被读作  "one 1"  ("一个一") , 即 11。 11 被读作 "two 1s" ("两个一"）, 即 21。 21 被读作 "one 2",  "one 1" （"一个二" ,  "一个一") , 即 1211。
给定一个正整数 n（1 ≤ n ≤ 30），输出外观数列的第 n 项。

注意：整数序列中的每一项将表示为一个字符串。

利用队列先进先出的性质来做，从一个数列“1211”来考虑，假设现在队列中存放的这个1211，那么用一个变量qsize记录其长度4，遍历完4次结束，每次遍历都检测弹出的数和队列头是否相等，用一个计数变量count来记录重复次数，如果不相等了则往队列里push count和tmp两个数，否则只加count不往队列push。

这样一个数列1211执行完4次后队列里就剩下111221这个数列，正好是下一个，最外层再用一个for循环记录要取的次数。

class Solution {
public:
     string countAndSay(int n) {
        string res="";
        int count=0,tmp=1,bt=0,qsize=1;
        queue<int> que;
        que.push(1);
        for(int i=2;i<=n;i++){
            while(qsize>0){
                if(que.front()==tmp) count++;
                else{
                    que.push(count);
                    que.push(bt);
                    count=1;
                    tmp=que.front();   
                }
                bt=que.front(); 
                que.pop();
                qsize--;
            }
            que.push(count);
            que.push(bt);
            tmp=que.front(); 
            count=0;
            qsize=que.size();    
        }
        while(!que.empty()){
            res +=to_string(que.front());
            que.pop();
        }
        return res;
    }
};

最长公共前缀

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

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

示例 1:

输入: [“flower”,“flow”,“flight”] 输出: “fl” 示例 2:

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

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

一次遍历就OK了。

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if(strs.empty())
            return "";
        string str = strs[0];
        for(int i = 1; i < strs.size();i++){
            int j = 0;
            while(j <= strs[i].size()-1 && j <= str.size()-1 && str[j] == strs[i][j])
                j++;
            str = str.substr(0,j);
        }
        return str;
    }
};