Question

假设我们有一个字符串“11222222345646”。那么如何在C中打印出子序列222222。我在这里有一个功能，但我觉得有些不对劲。有人能为我纠正吗？

int *longestsubstring(int a[], int n, int *length)
{
    int location = 0;
    length = 0;
    int i, j;

    for (i = 0, j = 0; i <= n-1, j < i; i++, j++)
    {
        if (a[i] != a[j])
        {
            if (i - j >= *length)
            {
                *length = i - j;
                location = j;
            }

            j = i;
        }
    }

    return &a[location];
}

Answer 1

对不起，我真的不明白你的问题。

我只有一些代码，它可以打印最长的子字符串，希望它可以提供帮助。

/*breif : print the longest sub string*/

void  printLongestSubString(const char * str,int length)
{
        if(length <= 0)
                return;
        int i ;
        int num1 = 0,num2 = 0;
        int location = 0;

        for(i = 0; i< length - 1; ++i)
        {
                if(str[i] == str[i+1])
                        ++num2;//count the sub string ,may be not the longest,but we should try.
                else
                {
                        if(num2 >num1)//I use num1 store the sum longest of current sub string.
                        {       num1 = num2;location = i - num2;}
                        else
                                ;//do nothing for short sub string.
                        num2 = 0;
                }
        }

        for(i = location;str[i]== str[num1];++i)
                printf("%c",str[i]);
        printf("\n");
}

int main()
{
        char * str = "1122222234566";
        printLongestSubString(str,13);
        return 0;
}

Answer 2

从您的代码中看起来您想要返回最长的子序列（子字符串）。因为我正在重新学习C，我想我会试一试。

我使用strndup来提取子字符串。我不确定它是多么便携，但我发现了一个实现，如果需要，只需点击链接即可。它将分配内存来存储新的cstring，因此你必须记住在完成子字符串后释放内存。在您的参数列表之后，子字符串的长度将作为提取例程的第三个参数返回。

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

char *extract_longest_subsequence(const char *str, size_t str_len, size_t *longest_len);

int main()
{
    char str[] = "11222234555555564666666";
    size_t substr_len = 0;
    char *substr = extract_longest_subsequence(str, sizeof(str), &substr_len);

    if (!substr)
    {
        printf("Error: NULL sub-string returned\n");
        return 1;
    }

    printf("original string: %s, length: %zu\n", str, sizeof(str)-1);
    printf("Longest sub-string: %s, length: %zu\n", substr, substr_len);

    /* Have to remember to free the memory allocated by strndup */
    free(substr);

    return 0;
}

char *extract_longest_subsequence(const char *str, size_t str_len, size_t *longest_len)
{
    if (str == NULL || str_len < 1 || longest_len == NULL)
        return NULL;

    size_t longest_start = 0;
    *longest_len = 0;
    size_t curr_len = 1;
    size_t i = 0;

    for (i = 1; i < str_len; ++i)
    {
        if (str[i-1] == str[i])
        {
            ++curr_len;
        }
        else
        {
            if (curr_len > *longest_len)
            {
                longest_start = i - curr_len;
                *longest_len = curr_len;
            }
            curr_len = 1;
        }
    }

    /* strndup allocates memory for storing the substring */
    return strndup(str + longest_start, *longest_len);
}

Answer 3

在你的循环中看起来j应该存储当前“substring”开始的地方，i是你当前正在查看的字符的索引。在这种情况下，您想要更改

for (i = 0, j = 0; i <= n-1, j < i; i++, j++)

到

for (i = 0, j = 0; i <= n-1; i++)

这样，您正在使用i来存储您正在查看的字符，而j = i行将“重置”您正在检查字符长度的字符串。

另外，还有其他一些事情：

1）length = 0应为*length = 0。您可能实际上并不想将指针设置为指向地址0x0。

2）最后一行将返回“最大子串”开始的位置，但它不会截断字符开始变化的位置（即结果字符串不一定是*length长）。它可能是故意的，具体取决于用例，但我想如果它可以节省一些悲伤，我会提到它。

打印出c中最长的子串

3 个答案: