用c语言输入任意给定的左线性文法，转换为等价的有限自动机，并以状态转换图方式输出

好的，以下是一个简单的 C 语言程序，可以将输入的左线性文法转换为等价的有限自动机，并以状态转换图方式输出。需要注意的是，由于左线性文法的特殊性质，转换出的有限自动机可能会比较复杂，因此在实际使用中可能需要进行优化。

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

#define MAX_RULES 100     // 最大产生式数量
#define MAX_LENGTH 100    // 最大符号串长度

// 存储产生式的结构体
struct Rule {
    char left;           // 产生式左部非终结符
    char right[MAX_LENGTH];  // 产生式右部终结符串
};

// 存储状态转换的结构体
struct Transition {
    int from;            // 起始状态
    int to;              // 终止状态
    char input;          // 输入字符
};

int main() {
    struct Rule rules[MAX_RULES];     // 存储所有的产生式
    int num_rules = 0;                // 产生式数量
    char start;                       // 起始非终结符
    int num_states = 0;               // 状态数量
    int accepting_states[MAX_LENGTH]; // 接受状态集合
    int num_accepting_states = 0;     // 接受状态数量
    struct Transition transitions[MAX_RULES * MAX_LENGTH]; // 存储所有的状态转换
    int num_transitions = 0;          // 状态转换数量

    // 读入产生式
    printf("请输入产生式，以空行结束：\n");
    char line[MAX_LENGTH];
    while (fgets(line, MAX_LENGTH, stdin) != NULL && line[0] != '\n') {
        if (num_rules >= MAX_RULES) {
            printf("产生式数量超过最大限制！\n");
            return 1;
        }
        if (sscanf(line, "%c->%s", &rules[num_rules].left, rules[num_rules].right) != 2) {
            printf("无效的产生式格式：%s", line);
            return 1;
        }
        num_rules++;
    }

    // 读入起始非终结符
    printf("请输入起始非终结符：\n");
    if (scanf("%c", &start) != 1) {
        printf("无效的起始非终结符！\n");
        return 1;
    }

    // 构造状态转换图
    for (int i = 0; i < num_rules; i++) {
        // 将产生式右部反转
        int len = strlen(rules[i].right);
        for (int j = 0; j < len / 2; j++) {
            char temp = rules[i].right[j];
            rules[i].right[j] = rules[i].right[len - j - 1];
            rules[i].right[len - j - 1] = temp;
        }

        // 构造状态转换
        int current_state = 0;
        for (int j = 0; j < len; j++) {
            // 查找当前状态是否已存在
            int next_state = -1;
            for (int k = 0; k < num_states; k++) {
                if (transitions[k].from == current_state && transitions[k].input == rules[i].right[j]) {
                    next_state = transitions[k].to;
                    break;
                }
            }
            if (next_state == -1) {
                // 新建转移状态
                next_state = num_states;
                num_states++;
                for (int k = 0; k < num_accepting_states; k++) {
                    if (accepting_states[k] == current_state) {
                        // 如果当前状态是接受状态，则新建的状态也是接受状态
                        accepting_states[num_accepting_states++] = next_state;
                        break;
                    }
                }
            }
            transitions[num_transitions++] = (struct Transition){current_state, next_state, rules[i].right[j]};
            current_state = next_state;
        }
        // 将最终状态设为接受状态
        accepting_states[num_accepting_states++] = current_state;
    }

    // 输出状态转换图
    printf("状态转换图如下：\n");
    printf("状态数量：%d\n", num_states);
    printf("接受状态数量：%d\n", num_accepting_states);
    printf("接受状态：");
    for (int i = 0; i < num_accepting_states; i++) {
        printf("%d ", accepting_states[i]);
    }
    printf("\n");
    printf("状态转换：\n");
    for (int i = 0; i < num_transitions; i++) {
        printf("%d --%c--> %d\n", transitions[i].from, transitions[i].input, transitions[i].to);
    }

    return 0;
}

输入格式为：

产生式1
产生式2
...
产生式n

起始非终结符

其中每个产生式的格式为 `非终结符->终结符串`，终结符串可以包含多个字符。例如，以下是一个左线性文法的示例输入：

S->aS
S->a

起始非终结符为 `S`。程序会输出状态转换图，例如：

状态转换图如下：
状态数量：3
接受状态数量：1
接受状态：2
状态转换：
0 --a--> 1
1 --a--> 2