用c语言写一个程序实现找出最长后缀字符串的功能

您好，下面是用c语言实现找出最长后缀字符串的程序：

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

int main() {
    char str[100]; // 声明字符串
    int len;
    printf("请输入一个字符串:\n");
    scanf("%s", str); // 获取输入的字符串
    len = strlen(str); // 获取字符串长度
    for(int i = len - 1; i >= 0; i--) { // 倒序遍历字符串
        if(str[i] == '.') { // 找到后缀的分隔符'.'
            printf("最长的后缀串是: %s\n", &str[i+1]); // 输出后缀串
            break;
        }
    }
    return 0;
}

希望能够帮到您！

相关问题

用c语言写一个程序实现找出最长公共后缀字符串的功能

可以使用字典树（Trie）的方法进行最长公共后缀的查找，具体实现步骤如下：

1. 将所有字符串插入到字典树中，并记录每个节点的出现次数。

2. 从根节点开始，对每个节点的子节点按照字典序排序，遍历排序后的最后一个节点。

3. 如果某个节点的出现次数等于字符串个数，说明这个节点可以作为最长公共后缀的候选节点。

4. 对于所有的候选节点，按照深度从小到大排序，选取深度最大的节点作为最长公共后缀。

实现代码如下：

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

#define MAX_N 100
#define MAX_L 100

typedef struct Node {
int cnt;
struct Node* next[26];
} Node;

void insert(Node* root, char* str) {
int len = strlen(str);
Node* cur = root;
for (int i = len - 1; i >= 0; --i) {
int idx = str[i] - 'a';
if (cur->next[idx] == NULL) {
cur->next[idx] = (Node*) malloc(sizeof(Node));
memset(cur->next[idx], 0, sizeof(Node));
}
cur = cur->next[idx];
++cur->cnt;
}
}

int dfs(Node* root, char* ans, int dep) {
int flag = 0;
for (int i = 0; i < 26; ++i) {
if (root->next[i] != NULL && root->next[i]->cnt == MAX_N) {
ans[dep] = 'a' + i;
flag = 1;
dfs(root->next[i], ans, dep + 1);
}
}
if (!flag && dep > 0) {
ans[dep] = '\0';
return 1;
}
return 0;
}

int main() {
int n;
char str[MAX_N][MAX_L];
Node* root = (Node*) malloc(sizeof(Node));
memset(root, 0, sizeof(Node));
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", str[i]);
insert(root, str[i]);
}
char ans[MAX_L];
dfs(root, ans, 0);
if (strcmp(ans, "") == 0) {
printf("No common suffix found.\n");
} else {
printf("The longest common suffix is \"%s\"\n", ans);
}
return 0;
}

1、字符串匹配问题 给定一个s字符串和一个n字符串，在s字符串中找出n字符串出现的第一个位置(从0开始)。如果不存在，则返回 -1 用c语言解决 具体代码和代码分析和运行结果 和常见的错误分析

这个问题可以使用经典的字符串匹配算法——KMP算法来解决。

KMP算法的核心是构建一个next数组，next数组的每个元素表示当前字符之前最长的相同前缀后缀长度。然后利用这个next数组进行匹配。

具体步骤如下：

1.构建next数组

void getNext(char* pattern, int* next)
{
    int i = 0, j = -1;
    next[0] = -1;
    int len = strlen(pattern);
    while (i < len - 1)
    {
        if (j == -1 || pattern[i] == pattern[j])
        {
            i++;
            j++;
            next[i] = j;
        }
        else
            j = next[j];
    }
}

2.匹配字符串

int KMP(char* s, char* pattern)
{
    int len1 = strlen(s);
    int len2 = strlen(pattern);
    int i = 0, j = 0;
    int* next = (int*)malloc(sizeof(int) * len2);
    getNext(pattern, next);
    while (i < len1 && j < len2)
    {
        if (j == -1 || s[i] == pattern[j])
        {
            i++;
            j++;
        }
        else
            j = next[j];
    }
    if (j == len2)
        return i - j;
    else
        return -1;
}

3.完整的代码

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

void getNext(char* pattern, int* next)
{
    int i = 0, j = -1;
    next[0] = -1;
    int len = strlen(pattern);
    while (i < len - 1)
    {
        if (j == -1 || pattern[i] == pattern[j])
        {
            i++;
            j++;
            next[i] = j;
        }
        else
            j = next[j];
    }
}

int KMP(char* s, char* pattern)
{
    int len1 = strlen(s);
    int len2 = strlen(pattern);
    int i = 0, j = 0;
    int* next = (int*)malloc(sizeof(int) * len2);
    getNext(pattern, next);
    while (i < len1 && j < len2)
    {
        if (j == -1 || s[i] == pattern[j])
        {
            i++;
            j++;
        }
        else
            j = next[j];
    }
    if (j == len2)
        return i - j;
    else
        return -1;
}

int main()
{
    char s[] = "hello, world!";
    char n[] = "world";
    int index = KMP(s, n);
    printf("Index: %d\n", index);
    return 0;
}

4.运行结果

Index: 7

5.常见错误分析

KMP算法的难点在于next数组的构建，容易出现错误的地方有两个：

- 对于next[0]的初始化应该为-1而不是0。
- 对于更新next数组的过程，应该首先判断j是否等于-1，如果是，则i++，j++，next[i]=j，否则j=next[j]。

此外还需要注意内存泄漏问题，需要手动释放next数组的内存。