[算法]力扣刷题-初级算法 - 字符串(二) [ 有效的字母异位词] [验证回文串] [字符串转换整数 (atoi)]

初级算法 - 数组篇完结：
https://blog.csdn.net/weixin_43854928/article/details/121315702
https://blog.csdn.net/weixin_43854928/article/details/121523946
https://blog.csdn.net/weixin_43854928/article/details/121568562

初级算法 - 字符串(一):
https://blog.csdn.net/weixin_43854928/article/details/121667057
初级算法 - 字符串(二):
https://blog.csdn.net/weixin_43854928/article/details/121736956

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
1 <= s.length, t.length <= 5 * 10^4
输入: s = “anagram”, t = “nagaram”
输出: true
s 和 t 仅包含小写字母
示例 1:
链接：https://leetcode-cn.com/problems/valid-anagram

思路1：

1. 先判断下长度，不相等的话直接输出false
2. 遍历字符串s，判断字符串s中的每个字符是否都在字符串t中出现过
3. 若出现过，把该位置位字符0（题目说明字符串仅有小写字母），标明该字符已经被对比发现过。
   时间复杂度：O(n²)
   空间复杂度：O(1)

bool isAnagram(char * s, char * t)
{
    unsigned short len_s = strlen(s);
    unsigned short len_t = strlen(t);

    if(len_s != len_t)
    {
        return false;
    }
    for(unsigned short i=0; i<len_s; i++)
    {
        char* char_p = memchr(t, s[i], len_t);

        if(char_p == 0)
        {
            return false;
        }
        else
        {
            *char_p = '0';
        }
    }
    return true;
}

思路2：

1. 因为出现的都是小写字母，且字符串长度小于5 * 10^4，直接创建26个元素的数组用来存储出现次数
2. 遍历字符串s，把字母对应下标的数组元素++
3. 遍历字符串t，把字母对应下标的数组元素- -
4. 最后遍历一遍数组看是否全为0，有非0的数据说明不相等，返回false

时间复杂度：O(n)
空间复杂度：O(n)

bool isAnagram(char * s, char * t)
{
    char letter_map[26] = {0};

    unsigned short len_s = strlen(s);
    unsigned short len_t = strlen(t);

    if(len_s != len_t)
    {
        return false;
    }

    for(unsigned short i=0; i<len_s; i++)
    {
        letter_map[s[i]-'a']++;
        letter_map[t[i]-'a']--;
    }

    for(char i=0; i<26; i++)
    {
        if(letter_map[i])
        {
            return false;
        }
    }
    return true;
}

125. 验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 说明：本题中，我们将空字符串定义为有效的回文串。
示例1: 输入: “A man, a plan, a canal: Panama” 输出: true
解释：“amanaplanacanalpanama” 是回文串
链接：https://leetcode-cn.com/problems/valid-palindrome

思路：

1. 双指针，一个从前向后，一个从后向前遍历字符串
2. 遍历到数字或字符时进行对比，其余字符跳过
3. 对比相等时继续遍历，不相等时返回false
4. 两个指针相交时结束，返回true

时间复杂度：O(n)
空间复杂度：O(1)

bool isPalindrome(char * s)
{
    short len = strlen(s);
    if(len < 2)
    {
        return true;
    }
    
    short forward = 0;
    short reverse = len-1;

    while (reverse-forward > 0)
    {
        while(s[forward] && !(s[forward]>='A' && s[forward]<='Z') && !(s[forward]>='a' && s[forward]<='z') && !(s[forward]>='0' && s[forward]<='9'))
        {
            forward++;
        }

        while(s[reverse] && !(s[reverse]>='A' && s[reverse]<='Z') && !(s[reverse]>='a' && s[reverse]<='z') && !(s[reverse]>='0' && s[reverse]<='9') && reverse>0)
        {
            reverse--;
        }

        if(reverse-forward < 1)
        {
            break;
        }

        if((s[forward] == s[reverse]) || 
        (((s[reverse]>='A' && s[reverse]<='Z') && (s[forward]>='a' && s[forward]<='z')) && s[forward]-s[reverse] == 'a'-'A')||
        (((s[forward]>='A' && s[forward]<='Z') && (s[reverse]>='a' && s[reverse]<='z')) && s[reverse]-s[forward] == 'a'-'A'))
        {
            forward++;
            reverse--;
        }
        else
        {
            return false;
        }
    }
    return true;

}

感觉这样写挺傻的，太多的边界和异常判断，但效率还行

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

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi函数）。
函数 myAtoi(string s) 的算法如下：
读入字符串并丢弃无用的前导空格 检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。
如果两者都不存在，则假定结果为正。 读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。
如果没有读入数字，则整数为 0。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [−2^31, 2^31 − 1]，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −2^31 ，大于 2^31 − 1 的整数应该被固定为 2^31 − 1 。 返回整数作为最终结果。
注意：
本题中的空白字符只包括空格字符 ’ ’ 。 除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。

链接：https://leetcode-cn.com/problems/string-to-integer-atoi

思路：
钻了个题目的漏洞，题目没有说不允许使用int64类型的数据

1. 先用while把前导空格都跳过。
2. 有加号的话把加号跳过。
3. 再用while遍历到数字部分的最后，把字符串中非数字部分截断。
4. 直接sscanf把数字字符串转到longlong里。
5. 判断，超过范围返回最大最小值，否则返回原值

时间复杂度:O(n)
空间复杂度：O(1)
int myAtoi(char * s)
{ 
    while(*s == ' ')
    {
        s++;
    }
    char* s_end_p = s;

    if(*s_end_p == '-')
    {
        s_end_p++;
    }
    else if(*s_end_p == '+')
    {
        s_end_p++;
        s++;
    }
    
    while(*s_end_p >= '0' && *s_end_p <= '9')
    {
        s_end_p++;
    }
    *s_end_p = '\0';
    long long long_data = 0;
    
    sscanf(s, "%ld", &long_data);

    if(long_data>(int)0x7FFFFFFF)
    {
        return (int)0x7FFFFFFF;
    }
    else if(long_data<(int)0x80000000)
    {
        return (int)0x80000000;
    }
    return (int)long_data;
}