-1

假设我们有一个字符串“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];
}
4

3 回答 3

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;
}
于 2013-07-19T23:44:27.403 回答
1

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

我使用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);
}
于 2013-07-20T05:54:35.707 回答
0

它看起来像在您的循环中j应该存储当前“子字符串”开始的位置，并且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很长）。根据用例，它可能是有意的，但我想我会提到它以防它节省一些悲伤。

于 2013-07-19T18:57:51.640 回答