Leetcode字符串刷题顺序

恁村扛把子

已于 2023-09-09 16:29:56 修改

阅读量255

点赞数 1

分类专栏： Leetcode 文章标签： leetcode 算法职场和发展

于 2021-01-01 13:28:54 首次发布

本文链接：https://blog.csdn.net/qq_43521670/article/details/112059868

版权

Leetcode 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

文章目录

5. 最长回文子串

难度中等21 36

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

知识准备：

马拉车算法：

过程：主要存储相关点的相关半径，回文中心记录一个值，最大的回文半径，从ｊ点向两边拉伸，回文半径长度

ｊ:回文中心，到右边最远，最远为ｐ主要是求c[i]，c[i]有对称的位置，一种包括ｉ一种不包括，可以找到i’点，

时间复杂度是O(1)的，总的时间复杂度是O(n)的

class Solution {
public:
    string get_new_str(string &s) {//将其字符间加入#解决偶个数字符
      string new_s = "#";
      for(int i = 0;i <  s.size(); i++) { 
        new_s += s[i];
        new_s += "#";
      }
      return new_s;
    }
    int r[1005];
    string longestPalindrome(string s) {
        int r[2010] = {0};
        string new_s = get_new_str(s);//获取处理后的字符串
        int ans = 0, ind = 0;
        for(int i = 0, j = 0, p = 0; new_s[i];i++ ) {
          r[i] = 1;
          if(i <= p&&r[2 * j - i] + i - 1 < p) {//第一种情况,
            r[i] = r[2 * j - i];//对称
          } else {//第二种情况
            r[i] = max(1, p - i + 1);//找到最大的
            while(i >= r[i] && new_s[i + r[i]] == new_s[i - r[i]]) r[i] ++;//一点一点往后试探
          }
          if(i + r[i] - 1 > p) {//更新p
            j = i, p = i + r[i] - 1;
          }
            if(r[i] > ans) {//最大的半径
            ans = r[i], ind = i;
            }
        }
        string sub_str = new_s.substr(ind - ans + 1, 2 * ans - 1);
        string ret = "";
        for(int i = 1;sub_str[i]; i+=2) ret += sub_str[i];
        return ret;
    }
};

8. 字符串转换整数 (atoi)

难度中等696

请你来实现一个 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) {
        int d = 0;
        istringstream is(str);//转化为流　is, 
        is>>d;//然后is 流向整形d中即可转化, 只有d同类型的值往里面流
        return d;
    }
};

方法二

class Solution {
public:
    int myAtoi(string str) {
      int flag = 1, num = 0, i = 0, pre_max = INT_MAX / 10, d = INT_MAX % 10;
      while(str[i] == ' ') i++;
      if(str[i] == '-')flag = -1, ++i;
        else if(str[i] == '+');
        num = num * 10 + (str[i] - '0');
        　return flag == 1? INT_MAX : INT_MIN;
          i++;
      }
        return num * flag;
    }
};

13. 罗马数字转整数

难度简单890

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如，罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: "III"
输出: 3

示例 2:

输入: "IV"
输出: 4

示例 3:

输入: "IX"
输出: 9

示例 4:

输入: "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3.

示例 5:

输入: "MCMXCIV"
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

 class Solution {
public:
    int getVal(char c) {
        switch (c) {
            case 'I' : return 1;
            case 'V' : return 5;
            case 'X' : return 10;
            case 'L' : return 50;
            case 'C' : return 100;
            case 'D' : return 500;
            case 'M' : return 1000;
        }
        return 0;
    }
    int romanToInt(string s) {
        int num = 0;
        for (int i = 0; s[i]; i++) {
            if (s[i + 1] == 0 || getVal(s[i]) >= getVal(s[i + 1])) {
                num += getVal(s[i]);
            } else {
                num -= getVal(s[i]);
            }
        }
        return num;
    }
};

14. 最长公共前缀

难度简单1002

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

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

示例 1:

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

示例 2:

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

说明:

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

28. 实现 strStr()

难度简单441

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

class Solution {
public:
    int strStr(string haystack, string needle) {
       int ind[256];
        for(int i = 0; i < 265; i++) ind[i] = needle.size() + 1;
        for(int i = 0; needle[i]; i++) {
            ind[needle[i]] = needle.size() - i;
        }
        for(int i = 0, I = haystack.size() - needle.size(); i <= I;) {
            int  j = 0;
            for(; needle[j]; j++) {
                if(haystack[i + j] == needle[j])continue;
                i += ind[haystack[i + needle.size()]];
                break;
            } 
            if(needle[j] == 0)return i;
        }
        return -1;
    }
};

36. 有效的数独

难度中等330

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

上图是一个部分填充的有效的数独。

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1:

输入:
[
  ["5","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]
]
输出: true

示例 2:

输入:
[
  ["8","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]
]
输出: false
解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。
     但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。

说明:

一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
给定数独序列只包含数字 1-9 和字符 '.' 。
给定数独永远是 9x9 形式的。

class Solution {
public:
    int x[9], y[9], z[9];
    bool isValidSudoku(vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) x[i] = y[i] = z[i] = 0;//初始化为0
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (board[i][j] == '.') continue;
                int num = board[i][j] - '0';
                if (x[i] & (1 << num)) return false;
                if (y[j] & (1 << num)) return false;
                if (z[i / 3 * 3 + j / 3] & (1 << num)) return false;
                x[i] |= (1 << num);
                y[j] |= (1 << num);
                z[i / 3 * 3 + j / 3] |= (1 << num);
            }
        }
        return true;
    }
};

58. 最后一个单词的长度

难度简单196

给定一个仅包含大小写字母和空格 ' ' 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。

如果不存在最后一个单词，请返回 0 。

**说明：**一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。

示例:

输入: "Hello World"
输出: 5

方法一

class Solution {
public:
    int lengthOfLastWord(string s) {
        reverse(s.begin(),s.end());//翻转一下，让最后一个单词在前面
        string w;
        istringstream is(s);
        is>>w;//使用流流入w中
        return w.size();
    }
};

方法二

class Solution {
public:
    int lengthOfLastWord(string s) {//找到两个空格位置
        if (s == "") return 0;
        int p1 = s.size() - 1, p2;
        while (p1 >= 0 && s[p1] == ' ') --p1;
        p2 = p1;
        while (p2 >= 0 && s[p2] != ' ') --p2;
        return p1 - p2;
    }
};

125. 验证回文串

难度简单191

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

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

示例 1:

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

示例 2:

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

class Solution {
public:
    bool isAlpha(char ch) {
        return ch <= 'z' && ch >= 'a';
    }
    bool isDigit(char ch) {
        return ch <= '9' && ch >= '0';
    }
    bool isPalindrome(string s) {
        int p1 = 0, p2 = s.size() - 1;
        for (int i = 0; s[i]; i++) {
            if (s[i] <= 'Z' && s[i] >= 'A') s[i] += 32;
        }
        while (p1 < p2) {//两个指针一个往左走，一个往右走
            while (p1 < s.size() && !isAlpha(s[p1]) && !isDigit(s[p1])) ++p1;
            while (p2 >= 0 && !isAlpha(s[p2]) && !isDigit(s[p2])) --p2;
            if (p1 >= p2) break;
            if (s[p1] != s[p2]) return false;
            p1++, p2--;
        }
        return true;
    }
};

165. 比较版本号

难度中等79

比较两个版本号 version1 和 version2。
如果 *version1* > *version2* 返回 1，如果 *version1* < *version2* 返回 -1，除此之外返回 0。

你可以假设版本字符串非空，并且只包含数字和 . 字符。

. 字符不代表小数点，而是用于分隔数字序列。

例如，2.5 不是“两个半”，也不是“差一半到三”，而是第二版中的第五个小版本。

你可以假设版本号的每一级的默认修订版号为 0。例如，版本号 3.4 的第一级（大版本）和第二级（小版本）修订号分别为 3 和 4。其第三级和第四级修订号均为 0。

示例 1:

输入: version1 = "0.1", version2 = "1.1"
输出: -1

示例 2:

输入: version1 = "1.0.1", version2 = "1"
输出: 1

示例 3:

输入: version1 = "7.5.2.4", version2 = "7.5.3"
输出: -1

示例 4：

输入：version1 = "1.01", version2 = "1.001"
输出：0
解释：忽略前导零，“01” 和 “001” 表示相同的数字 “1”。

示例 5：

输入：version1 = "1.0", version2 = "1.0.0"
输出：0
解释：version1 没有第三级修订号，这意味着它的第三级修订号默认为 “0”。

提示：

版本字符串由以点（.）分隔的数字字符串组成。这个数字字符串可能有前导零。
版本字符串不以点开始或结束，并且其中不会有两个连续的点。

代码一、

class Solution {
public:
    int compareVersion(string version1, string version2) {
        int i = 0, j = 0;
        while (version1[i] || version2[j]) {
            int val1 = 0;
            int val2 = 0;
            while (version1[i] && version1[i] <= '9' && version1[i] >= '0') {
                val1 = val1 * 10 + version1[i] - '0';
                i++;
            }
            while (version2[j] && version2[j] <= '9' && version2[j] >= '0') {
                val2 = val2 * 10 + version2[j] - '0';
                j++;
            }
            if (val1 - val2) return val1 > val2 ? 1 : -1;
            if (version1[i]) ++i;
            if (version2[j]) ++j;
        }
        return 0;
    }
};

代码二、

class Solution {
public:
    int getNext(string &str, int i, int &val) {
        val = 0;
        while (str[i] && str[i] <= '9' && str[i] >= '0') {
            val = val * 10 + str[i] - '0';
            i++;
        }
        if (str[i]) ++i;
        return i;
    }
    int compareVersion(string version1, string version2) {
        int i = 0, j = 0, val1, val2;
        while (version1[i] || version2[j]) {
            i = getNext(version1, i, val1);
            j = getNext(version2, j, val2);
            if (val1 - val2) return val1 > val2 ? 1 : -1;
        }
        return 0;
    }
};

205. 同构字符串

难度简单193

给定两个字符串 s 和 t，判断它们是否是同构的。

如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。

所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 1:

输入: s = "egg", t = "add"
输出: true

示例 2:

输入: s = "foo", t = "bar"
输出: false

示例 3:

输入: s = "paper", t = "title"
输出: true

说明:
你可以假设 s 和 t 具有相同的长度。

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        if (s.size() - t.size()) return false;
        int s_code[256] = {0}, t_code[256] = {0};
        for (int i = 0; s[i]; i++) {
            if (s_code[s[i]] == 0) {
                if (t_code[t[i]]) return false;
                s_code[s[i]] = t[i];
                t_code[t[i]] = s[i];
            }
            int val = s_code[s[i]];
            if (val - t[i]) return false;
        }
        return true;
    }
};

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        int a[128] = {0}, b[128] = {0};
            if(s.size()!=t.size())return false;
    for(int i = 0; i < s.size(); i++) {
        a[s[i]] += i + 1;
        b[t[i]] += i + 1;
        if(a[s[i]] != b[t[i]]) {
            return false;
        }
    }
    return true;
    }
};

242. 有效的字母异位词

难度简单192

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

示例 1:

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

示例 2:

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

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

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

int cmp(const void *a, const void *b) {
    return (*(char *)a - *(char *)b);
}
bool isAnagram(char * s, char * t){
    qsort(s,  strlen(s), sizeof(char), cmp);
    qsort(t,  strlen(t), sizeof(char), cmp);
    return strcmp(s , t)==0 ? true : false;
}

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() - t.size()) return false;
        int code[256] = {0};
        for (int i = 0; s[i]; i++) code[s[i]] += 1;
        for (int i = 0; t[i]; i++) {
            if (code[t[i]] == 0) return false;
            code[t[i]] -= 1;
        }
        return true;
    }
};

290. 单词规律

难度简单150

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false

示例 4:

输入: pattern = "abba", str = "dog dog dog dog"
输出: false

说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。

class Solution {
public:
    string getNext(string &s, int &i) {
        while (s[i] == ' ') ++i;
        string ret = "";
        while (s[i] && s[i] != ' ') ret += s[i++];
        return ret;
    }
    bool wordPattern(string p, string s) {
        string p_code[256], temp;
        unordered_map<string, char> s_code;
        int ind = 0;
        for (int i = 0; p[i]; i++) {
            temp = getNext(s, ind);
            if (temp == "") return false;
            if (p_code[p[i]] == "") {
                if (s_code.find(temp) != s_code.end()) return false;
                p_code[p[i]] = temp;
                s_code[temp] = p[i];
            }
            if (p_code[p[i]] != temp) return false;
        }
        if (s[ind]) return false;
        return true;
    }
};

344. 反转字符串

难度简单242

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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, j = s.size() - 1; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
        return ;
    }
};

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

难度简单88

编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

示例 1:

输入: "hello"
输出: "holle"

示例 2:

输入: "leetcode"
输出: "leotcede"

说明:
元音字母不包含字母"y"。

class Solution {
public:
    bool is_valid(char ch) {
        if (ch < 97) ch += 32;
        switch (ch) {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u': return true;
        }
        return false;
    }
    string reverseVowels(string s) {
        for (int i = 0, j = s.size() - 1; i < j; i++, j--) {
            while (i < j && !is_valid(s[i])) ++i;
            while (i < j && !is_valid(s[j])) --j;
            if (i >= j) break;
            swap(s[i], s[j]);
        }
        return s;
    }
};

383. 赎金信

难度简单91

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true

class Solution {
public:
    bool canConstruct(string r, string m) {
        int code[256] = {0};
        for (int i = 0; m[i]; i++) code[m[i]] += 1;
        for (int i = 0; r[i]; i++) {
            if (code[r[i]] == 0) return false;
            code[r[i]]--;
        }
        return true;
    }
};

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

难度简单211

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

案例:

s = "leetcode"
返回 0.

s = "loveleetcode",
返回 2.

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

class Solution {
public:
    int firstUniqChar(string s) {
        int code[256] = {0};
        for (int i = 0; s[i]; i++) code[s[i]] += 1;
        for (int i = 0; s[i]; i++) if (code[s[i]] == 1) return i;
        return -1;
    }
};

恁村扛把子

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Leetcode字符串刷题顺序

5. 最长回文子串知识准备：8. 字符串转换整数 (atoi)13. 罗马数字转整数14. 最长公共前缀28. 实现 strStr()36. 有效的数独58. 最后一个单词的长度125. 验证回文串文章目录[5. 最长回文子串](https://leetcode-cn.com/problems/longest-palindromic-substring/)知识准备：[8. 字符串转换整数 (atoi)](https://leetcode-cn.com/problems/string-to
复制链接

扫一扫

专栏目录