【字符串】若干编程

1.求一个字符串中连续出现次数最多的子串。

我自己的思路：

遍历所有可能的子串的长度，遍历所有可能的起始位置，后面遍历查找有多少连续相同的子串，更新最大次数。

我是用C实现的。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char * maxTimeSubStr(const char * str_in)
{
    int n = strlen(str_in);
    char * word = (char *)malloc((n + 1) * sizeof(char));
    char * tmp = (char *)malloc((n + 1) * sizeof(char));
    char * max_times_word = (char *)malloc((n + 1) * sizeof(char));
    int max_times = 0;
    for(int i = 1; i <= n; i++) //长度
    {
        for(int j = 0; j + i < n; j++) //起始位置
        {
            int times = 1;
            int k;
            for(k = 0; k < i; k++)//获取当前的字符串
            {
                word[k] = str_in[j + k];
            }
            word[k] = '\0';

            for(int k = j + i; k + i - 1 < n; k += i) //查找后面有几个连续相同的字符串 这是每个字符串的起始位置
            {
                bool bsame = true;
                for(int l = 0; l < i; l++) //新字符串逐位比较
                {
                    if(str_in[k + l] != word[l])
                    {
                        bsame = false;
                        break;
                    }
                }
                if(bsame)
                    times++;
                else
                    break;
            }
            if(times > max_times)
            {
                max_times = times;
                strcpy(max_times_word, word);
            }
        }
    }

    free(word);
    free(tmp);
    return max_times_word;
}

int main()
{
    char * c = maxTimeSubStr("abcabjalsfjalg ajaslcabcabcccas");
    return 0;
}

书上答案的思路：用C++实现的

思路是遍历所有的子串起始位置，遍历所有的子串结束位置，判断后面连续子串个数。

关键不同点：

①我遍历的是所有的长度和所有起始点，而答案遍历的是所有起始点和终点。用答案的方法会写代码的时候思路更清楚。

//14.5 例1 答案
#include <iostream>
#include <string>
#include <vector>

using namespace std;
pair<int, string> fun(const string & str)
{
    vector<string> substrs;
    int maxcount = 0, count = 1;
    string substr;
    int i, len = str.length();
    for(i = 0; i < len; ++i) //遍历所有子串起始位置
    {
        for(int j = i + 1; j < len; ++j) //遍历所有子串终点位置
        {
            count = 1;
            for(int k = j; k < len; k += j - i) //判断后面有多少个连续的 以 str[i] 到 str[j]组成的子串 k是下一个子串的开始位置
            {
                if(str.substr(i, j - i) == str.substr(k, j - i))
                    ++count;
                else
                    break;
            }
            if(count > maxcount)
            {
                maxcount = count;
                substr = str.substr(i, j - i);
            }
        }
    }
    return make_pair(maxcount, substr);
}

int main()
{
    string str;
    pair<int, string> rs;
    while(cin >> str)
    {
        rs = fun(str);
        cout << rs.second << ':' << rs.first << '\n';
    }
    return 0;
}