Leetcode初级总结（二）字符串

字符串的基本操作

在 C 语言中，字符串是使用 null 字符 ‘\0’ 终止的一维字符数组。

1、字符串的初始化

char str[] = "Hello";
char str1[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
char * str2 = "Hello";

2、字符串操作函数

• strlen(s1);
  返回字符串s1的长度
• strcat(s1,s2);
  连接字符串s2到字符串s1的末尾
• strcpy(s1,s2);
  复制字符串s2到字符串s1
• strcmp(s1,s2);
  如果s1和s2是相同的，则返回0；如果s1<s2则返回小于0；如果 s1>s2 则返回大于 0
• strchr(s1, ch);
  返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置
• strstr(s1, s2);
  返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置

leetcode中字符串的初级题目

1、反转字符串

• 题目描述
  编写一个函数，其作用是将输入的字符串反转过来。
  示例：
  输入: “hello”
  输出: “olleh”
• 解题思路
  利用字符串的下标交换，将字符串的内容对半交换，完成反转的效果。学习新的交换数字的方法
• 代码

char* reverseString(char* s) {
    int len = strlen(s);
    if(len <= 1)
        return s;
    
    for(int i=0 ,j=len-1; i<j; i++,j--) {
        
        s[i] = s[i]^s[j];
        s[j] = s[i]^s[j];
        s[i] = s[i]^s[j];
    }
    
    return s;
}

2、整数反转

• 题目描述
  给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
  示例1：
  输入: 123
  输出: 321
  示例2：
  输入: -123
  输出: -321
  示例 3：
  输入: 120
  输出: 21

• 解题思路
  为了防止溢出，先定义一个long型的变量result，用来存放反转后的结果。将整数从个位开始取，每次取一位，先给result乘10，然后将这个数字加到result中，将个位变成反转后的高位，最后判断result在不在int的有效范围内。

• 代码

int reverse(int x) {
    
    const int int_max = 0x7fffffff;
    const int int_min = 0x80000000;
    
     long result = 0;
    
    while (x!=0) {
        result = result*10 + (x%10);  
        x /= 10;
    }
    if(result<int_min || result>int_max) {
        result = 0;
    }
    
    return result;
    
}

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

• 题目描述
  给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
  示例：
  s = “leetcode”，返回 0.
  s = “loveleetcode”，返回 2.

• 解题思路
  从前往后挨个找，找到有重复的就退出循环，再看它的下一个是不是没有重复，如果找到了没有重复的元素，就返回这个元素的下标，如果找到最后还是没有就返回-1。

• 代码

int firstUniqChar(char* s) {
    int len = strlen(s);
    int i=0,j=0;
    
    if(0<len&&len<=1)
        return 0;
    
    for(i=0;i<=len-1;i++)
    {
        
        for(j=0;j<=len-1;j++)
        {
            if(s[i]==s[j]&&i!=j)
                break;
            
            if(j==len-1)
                return i;
        }
        
    }
    
     return -1;
}

4、有效的字母异位词

• 题目描述
  给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。
  示例 1：
  输入: s = “anagram”, t = “nagaram”
  输出: true
  示例2：
  输入: s = “rat”, t = “car”
  输出: false

• 解题思路
  判断两个字符串中每个字母出现的次数是否一样多，因为字母异位词是字母的位置不一样，字母的数量是一样的。

• 代码

bool isAnagram(char* s, char* t) {
    if (s == NULL || t == NULL) return false;

    int lens = strlen(s);
    int lent = strlen(t);
    if (lens != lent) return false;

    int flag[26] = { 0 };
    int i;
    for (i = 0; i < lens; i++){
        flag[s[i] - 'a']++;
    }

    for (i = 0; i < lent; i++) {
        flag[t[i] - 'a']--;
    }

    for (i = 0; i < 26; i++){
        if (flag[i] != 0) return false;
    }

    return true;
}

5、验证回文字符串

• 题目描述
  定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
  示例：
  输入: “A man, a plan, a canal: Panama”
  输出: true

• 解题思路
  两个指针i和j，一个从字符串首开始、一个从字符串尾部开始，只考虑字母个数字字符，如果i和j下标所对的元素值不一样，就说明不是回文字符串，直接返回false，i每次向后移一位，j向前移一位；如果i>=j了，他们的值一直一样，就说明是个回文字符串。

• 代码

bool isPalindrome(char* s) {
    int len = strlen(s);
    int i, j;
    
  
    if(len==0 || len==1)
    {
        return true;
    }
    
    if(len > 1)
    {
        i = 0;
        j = len-1;
         while(i<j)
         {
             if(!((s[i]>='a'&&s[i]<='z')||(s[i]>='A'&&s[i]<='Z')||(s[i]>='0'&&s[i]<='9')))
             {
                 i++;
                 continue;
             }
             
             if(!((s[j]>='a'&&s[j]<='z')||(s[j]>='A'&&s[j]<='Z')||(s[j]>='0'&&s[j]<='9')))
             {
                 j--;
                 continue;
             }
             if(s[i]!=s[j]&&(s[i]>='0'&&s[i]<='9'))
                 return false;
             if(s[i]!=s[j])   
             {
                 if(s[i]!=(s[j]+32))
                {
                    if(s[i]!=(s[j]-32))
                        return false;
                }
             }
                
             i++;
             j--;
         }
    }
   
    return true;
    
    
}

6、字符串转换整数（atoi）

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

• 解题思路
  首先需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。和之前的思路一样，先定义一个64位的整形，最后判断有没有超过32位的范围。在取字符串中的数字，往结果里加之前，一定要将数字字符转成整形数字（方法：str[s]-‘0’）。
  注意：32 位大小的有符号整数，那么其数值范围为 [−2^31, 2^31 − 1]

• 代码

 int myAtoi(char* str) {

    int i = 0,s,signal=1;
    int64_t num = 0;
    int l = strlen(str);

    if(str==NULL)
        return 0;

    for (i=0 ; i<l ; i++) {
        if (str[i]!=' ') {
            s=i;
            break;
        }
    }

     
    if(str[s]=='-') {
        signal = -1;
        s++;
    }
    else if (str[s]=='+') {
        
        signal = 1;
        s++;
    }

    while ((str[s]>='0')&&(str[s]<='9')) {
        num=num*10+(str[s]-'0');//将数字字符转换成整形数字，记住喽
        if (num-1>INT32_MAX) num = (int64_t)INT32_MAX+1;
        s++;
    }

    if(signal == -1) num = -num;
    if(num>INT32_MAX) num = INT32_MAX;
    if(num<INT32_MIN) num = INT32_MIN;
     
    return (int)num;

}

7、实现strStr()

• 题目描述
  实现 strStr() 函数。给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
  示例1：
  输入: haystack = “hello”, needle = “ll”
  输出: 2
  示例2：
  输入: haystack = “aaaaa”, needle = “bba”
  输出: -1

• 解题思路
  先在haystack中找到和needle中第一个元素相同的位置i，然后从这个位置开始逐个比较haystack和needle的值，用一个flag标记，如果遇到了不一样的元素，将flag置为false，再从i的下一个开始找和needle[0]相同的元素，如果needle找完了，flag的值还是true，那么返回下标i。如果haystack找完了，还是没有，就说明needle没在haystack出现过，返回-1。

• 代码

 int strStr(char* haystack, char* needle) {
    
    int s1 = strlen(haystack);
    int s2 = strlen(needle);
    int i,j,index=-1;
    
    if (needle==NULL||s2==0) {
        return 0;
    }
    
    if (s1<s2) {
        return -1;
    }
    
    for (i=0; i<s1; i++ ) {
            if (haystack[i] == needle[0]) {
                int m,n;
                bool flag=true;
                for(m=i,n=0; m<s1,n<s2; m++,n++) {
                    if(haystack[m]!=needle[n]) {
                        flag=false;
                        break;
                    }
                }
                if(flag)
                    return i;
                
            }
        }
     return -1;
    }

8、报数

• 题目描述
  报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：
  1
  11
  21
  1211
  111221
  1 被读作 “one 1” (“一个一”) , 即 11。
  11 被读作 “two 1s” (“两个一”）, 即 21。
  21 被读作 “one 2”, “one 1” （“一个二” , “一个一”) , 即 1211。
  给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。

• 解题思路

• 代码

#define maxn 10005
char s[maxn], t[maxn];
 
char* countAndSay(int n) {
    
    
    strcpy(s, "1");
    strcpy(t, "");
    int cnt = 1;
    char tmp[3];
    for(int i = 2;i <= n;i++){
        int len = strlen(s); 
        for(int j = 0;j < len;j++){
            if(s[j] == s[j + 1]){
                cnt++;
            }else {
                tmp[0] = cnt + '0';
                tmp[1] = s[j];
                tmp[2] = '\0';
                strcat(t, tmp);
                cnt = 1;
            }
        }
        strcpy(s, t);
        strcpy(t, "");
    }
    
    return s; 
}

9、最长公共前缀

• 题目描述
  编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 “”。（所有输入只包含小写字母 a-z 。）
  示例1：
  输入: [“flower”,“flow”,“flight”]
  输出: “fl”
  示例2：
  输入: [“dog”,“racecar”,“car”]
  输出: “”
  解释: 输入不存在公共前缀

• 解题思路
  将第一个字符串拷贝到字符串str中，将str的第一位和依次其他字符串的第一位比较，如果其他字符串的第一位都和str中的第一位元素相同，就再比较第二位，如果遇到了不一样的，就直接在当前位置停止（加上’\0’），返回str，此时str中的内容就是这个字符串组的最长总共前缀。

• 代码

//审题，是字符串数组
char* longestCommonPrefix(char** strs, int strsSize) {
    /*strs是一个字符串数组，也就是二维数组。strs[1][1]表示第二个字符串中的第二个字符。
    char**是二重指针,strs[0]就是char**型，存放的是char*型的子字符串
    因此定义一个char*型的变量str，然后将这个指针变量初始化指向字符串str[0]，也就是把字符串str[0]的第一个字符的地址赋值给指针
    因此str代表的是第一个子字符串，str[0]表示的是子字符串的第一个字符
    */
    
    //如果是空字符串，返回''
    if(strsSize==0) return "";
    //如果只有一个字符串，返回这个字符串
    if(strsSize==1) return strs[0];
    
    char* str = strs[0];
    int i,j;
    if (strsSize==0)
        return "";
    
    for (i=1; i<strsSize; i++) {
        j=0;
        while (str[j]&&strs[i][j]&&str[j]==strs[i][j])
            j++;
        str[j] = '\0';
    }
    
    return str;
    

    
    
}