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-integer-atoi/)
        • [13. 罗马数字转整数](https://leetcode-cn.com/problems/roman-to-integer/)
        • [14. 最长公共前缀](https://leetcode-cn.com/problems/longest-common-prefix/)
        • [28. 实现 strStr()](https://leetcode-cn.com/problems/implement-strstr/)
        • [36. 有效的数独](https://leetcode-cn.com/problems/valid-sudoku/)
        • [58. 最后一个单词的长度](https://leetcode-cn.com/problems/length-of-last-word/)
        • [125. 验证回文串](https://leetcode-cn.com/problems/valid-palindrome/)
        • [165. 比较版本号](https://leetcode-cn.com/problems/compare-version-numbers/)
        • [205. 同构字符串](https://leetcode-cn.com/problems/isomorphic-strings/)
        • [242. 有效的字母异位词](https://leetcode-cn.com/problems/valid-anagram/)
        • [290. 单词规律](https://leetcode-cn.com/problems/word-pattern/)
        • [344. 反转字符串](https://leetcode-cn.com/problems/reverse-string/)
        • [345. 反转字符串中的元音字母](https://leetcode-cn.com/problems/reverse-vowels-of-a-string/)
        • [383. 赎金信](https://leetcode-cn.com/problems/ransom-note/)
        • [387. 字符串中的第一个唯一字符](https://leetcode-cn.com/problems/first-unique-character-in-a-string/)

5. 最长回文子串

难度中等21 36

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

示例 1:

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

示例 2:

输入: "cbbd"
输出: "bb"
知识准备:
  • 马拉车算法:

    Leetcode字符串刷题顺序_第1张图片过程:主要存储相关点的相关半径,回文中心记录一个值,最大的回文半径,从j点向两边拉伸,回文半径长度Leetcode字符串刷题顺序_第2张图片

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

    Leetcode字符串刷题顺序_第3张图片

    时间复杂度是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

罗马数字包含以下七种字符: IVXLCDM

字符          数值
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. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

Leetcode字符串刷题顺序_第4张图片

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

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

示例 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

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

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

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

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

你可以假设版本号的每一级的默认修订版号为 0。例如,版本号 3.4 的第一级(大版本)和第二级(小版本)修订号分别为 34。其第三级和第四级修订号均为 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”。

提示:

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

代码一、

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

给定两个字符串 st,判断它们是否是同构的。

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

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

示例 1:

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

示例 2:

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

示例 3:

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

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

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

给定两个字符串 st ,编写一个函数来判断 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;
    }
};

你可能感兴趣的:(Leetcode)