[算法]力扣刷题-初级算法 - 字符串(三)(字符串篇完结) [实现 strStr()] [外观数列] [最长公共前缀]

初级算法 - 数组篇完结：
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

28. 实现 strStr()

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。
示例 1：
输入：haystack = “hello”, needle = “ll” 输出：2
示例 2：
输入：haystack = “aaaaa”, needle = “bba” 输出：-1
链接：https://leetcode-cn.com/problems/implement-strstr

思路1：
暴力破解：

int strStr(char * haystack, char * needle)
{
    for(int i = 0; i<strlen(haystack)+1; i++)
    {
        start:
        if(strlen(needle)+i > strlen(haystack))
        {
            return -1;
        }
        for(int j=0; j<strlen(needle); j++)
        {
            if(haystack[i+j] != needle[j])
            {
                i++;
                goto start;
            }
        }
        return i;
    }
    return -1;
}

思路2：
应该是要用KMP算法的，这里先挖个坑，之后填

38. 外观数列

给定一个正整数 n ，输出外观数列的第 n 项。
「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。
你可以将其视作是由递归公式定义的数字字符串序列：
countAndSay(1) = “1” countAndSay(n) 是对 countAndSay(n-1)
的描述，然后转换成另一个数字字符串。 前五项如下：

1. 1
   

2. 11
   

3. 21
   

4. 1211
   

5. 111221 
   

第一项是数字 1 描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 “11”
描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 “21”
描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 “1211”
描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 “111221”
示例 1：
输入：n = 1 输出：“1”
解释：这是一个基本样例。
示例 2：
输入：n = 4 输出：“1211”
解释： countAndSay(1) = “1”
countAndSay(2) = 读 “1” = 一个 1 = “11”
countAndSay(3) = 读 “11” = 二 个 1 = “21”
countAndSay(4) = 读"21" = 一 个 2 + 一 个 1 = “12” + “11” = “1211”
链接：https://leetcode-cn.com/problems/count-and-say

思路：
题目中说的：countAndSay(n) 是对 countAndSay(n-1) 的描述,自然而然地想到用递归解决：

1. countAndSay函数内递归传入n-1，递归到n==1时，返回malloc的字符串"1"
2. AndSay_trans函数则是将数字字符串处理为对应的外观数列字符串并返回
3. 处理方法比较简单，使用num变量记录当前字符，遍历输入字符串。
   若相同，count++表示数据个数+1。
   若不同，将count个num写入ret_str中，并更新num为当前的字符。

char * AndSay_trans(char * data)
{
    int num = *data;
    char* ret_str = calloc(4500,1);
    int write_index = 0;
    int count = 1;
    const int len = strlen(data);
    for(int i = 0; i<len; i++)
    {
        if(num == data[i+1])//这里不算越界，\0
        {
            count++;
        }
        else
        {
            ret_str[write_index++] = count+'0';
            ret_str[write_index++] = num;
            num = data[i+1];
            count = 1;
        }
    }
    free(data);
    return ret_str;
}

char * countAndSay(int n)
{
    if(n > 1)
    {
        return AndSay_trans(countAndSay(n -1));
    }
    else
    {
        char* ret_data = calloc(2,1);
        *ret_data = '1';
        return ret_data;
    }
}

这个算法的最大问题是，malloc的ret_str内存大小是按照题目中 1 <= n <= 30 的限制条件推算出的大概值，一是存在浪费，二是如果n的限制变大了，当前代码就不适用了。

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
示例 1：
输入：strs = [“flower”,“flow”,“flight”] 输出：“fl”
示例 2：
输入：strs = [“dog”,“racecar”,“car”] 输出：“”
解释：输入不存在公共前缀。
链接：https://leetcode-cn.com/problems/longest-common-prefix

思路：
用第一个字符串作为基准，逐字符对比其他字符串的相同位置的字符是否相同，相同就copy到缓存里，不同就退出。
感觉这题出的水平一般。

char * longestCommonPrefix(char ** strs, int strsSize)
{
    char* ret_str = calloc(201, 1);
    for(int i=0; i<strlen(strs[0]); i++)
    {
        for(int j=1; j< strsSize; j++)
        {
            if(strs[0][i] != strs[j][i])
            {
                //ret_str[i] = '\0';
                return ret_str;
            }
        }
        ret_str[i] = strs[0][i];
    }
    return ret_str;
}

唯一需要注意的点是：没有用直接截断strs[i]的方法，而是用malloc一块额外的内存用来放公共前缀，
是怕题目中传入的是字符常量，没办法截断，平时写代码如果不是内存极为紧张的情况下也尽量不在函数内对源数据进行操作。