多层括号化学式解析问题：C程序错误修正与优化咨询

你的代码在处理单层括号时正常，但嵌套括号的系数无法正确传递相乘，核心原因是：

• 处理外层括号时，仅迭代遍历内部字符，遇到内层括号直接跳过，没有递归解析内层括号的结构，导致内层括号后的系数（比如(SO3)4的4）没有参与到原子数量的计算中。
• 数字处理仅支持单个字符（如'5'），无法处理多位数系数（如10）。
• 项系数termCoefficient的获取逻辑错误，原代码从括号后读取，实际应该读取公式开头的数字。

1. 重构为递归解析逻辑 #

将化学式解析抽为递归函数，遇到嵌套括号时，递归处理内层片段，并传递当前累积的乘数（所有外层系数的乘积），确保每一层的系数都能正确相乘。

2. 修复数字解析逻辑 #

实现通用的数字读取函数，读取连续的数字字符转换为整数，支持多位数。

3. 修正项系数获取 #

正确读取公式开头的数字作为整个项的系数（比如2F2(SO4)3的2）。

修改后的完整代码 #

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

typedef struct {
    char symbol[3];  // Atom symbol (e.g., "H", "O")
} Atom;

typedef struct {
    char term[50];    // Formula term (e.g., "2H2O", "3CO2")
    char variable;    // Variable associated with the term
} Association;

// 读取连续数字，返回数值，并更新指针位置
int parseNumber(const char **str) {
    int num = 0;
    while (isdigit(**str)) {
        num = num * 10 + (**str - '0');
        (*str)++;
    }
    return num;
}

// 递归解析化学式片段，累加原子数量到表格
void parseFormulaFragment(const char *str, int currentMultiplier, int varIndex, Atom *atoms, int numAtoms, int **table) {
    while (*str != '\0' && *str != ')') {
        if (isdigit(*str)) {
            // 读取当前原子/组的系数
            int coeff = parseNumber(&str);
            // 递归处理后续内容，传递当前系数*已有乘数
            parseFormulaFragment(str, currentMultiplier * coeff, varIndex, atoms, numAtoms, table);
            // 跳过已处理的内容（由parseFragment内部推进指针）
            while (*str != '\0' && *str != ')' && !isupper(*str) && *str != '(') str++;
        } else if (isupper(*str)) {
            // 解析原子符号
            char symbol[3] = {*str, '\0'};
            str++;
            if (islower(*str)) {
                symbol[1] = *str;
                symbol[2] = '\0';
                str++;
            }
            // 读取原子后的系数，默认为1
            int atomCoeff = 1;
            if (isdigit(*str)) {
                atomCoeff = parseNumber(&str);
            }
            // 查找原子索引并累加数量
            for (int i = 0; i < numAtoms; i++) {
                if (strcmp(atoms[i].symbol, symbol) == 0) {
                    table[i][varIndex] += atomCoeff * currentMultiplier;
                    break;
                }
            }
        } else if (*str == '(') {
            str++; // 跳过左括号
            // 找到匹配的右括号
            int depth = 1;
            const char *end = str;
            while (*end != '\0' && depth > 0) {
                if (*end == '(') depth++;
                else if (*end == ')') depth--;
                end++;
            }
            // 读取括号后的系数，默认为1
            int groupCoeff = 1;
            if (isdigit(*end)) {
                groupCoeff = parseNumber(&end);
            }
            // 递归处理括号内的片段，乘数为当前乘数*组系数
            parseFormulaFragment(str, currentMultiplier * groupCoeff, varIndex, atoms, numAtoms, table);
            // 跳转到括号后的位置
            str = end;
        } else {
            str++; // 跳过其他字符（如空格等，可选处理）
        }
    }
}

void printVariableAtomTable(Atom *atoms, int numAtoms, Association *terms, int numTerms) {
    // 打印表头
    printf("\nTable of Association between Variables and Elements:\n");
    printf("Variable: ");
    for (int i = 0; i < numTerms; i++) {
        printf("%c  ", terms[i].variable);
    }
    printf("\n");

    // 分配表格内存
    int **table = (int **)malloc(numAtoms * sizeof(int *));
    if (table == NULL) {
        printf("Error: Failed to allocate memory for table.\n");
        exit(1);
    }
    for (int i = 0; i < numAtoms; i++) {
        table[i] = (int *)calloc(numTerms, sizeof(int));
        if (table[i] == NULL) {
            printf("Error: Failed to allocate memory for table.\n");
            exit(1);
        }
    }

    // 处理每个项
    for (int j = 0; j < numTerms; j++) {
        const char *term = terms[j].term;
        // 读取项的整体系数，默认为1
        int termCoeff = 1;
        if (isdigit(*term)) {
            termCoeff = parseNumber(&term);
        }
        // 递归解析整个项，初始乘数为项系数
        parseFormulaFragment(term, termCoeff, j, atoms, numAtoms, table);
    }

    // 打印表格
    for (int i = 0; i < numAtoms; i++) {
        printf("%s: ", atoms[i].symbol);
        for (int j = 0; j < numTerms; j++) {
            if (table[i][j] != 0) {
                if (table[i][j] == 1) {
                    printf("%c  ", terms[j].variable);
                } else {
                    printf("%d%c  ", table[i][j], terms[j].variable);
                }
            } else {
                printf("0%c  ", terms[j].variable);
            }
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < numAtoms; i++) {
        free(table[i]);
    }
    free(table);
}

int main() {
    Atom atoms[] = { {"F"}, {"O"}, {"S"}, {"H"}, {"Na"} };
    Association terms[] = { {"2F2(SO4)3", 'A'}, {"Na(H2(SO3)4)5", 'B'} };
    int numAtoms = sizeof(atoms) / sizeof(Atom);
    int numTerms = sizeof(terms) / sizeof(Association);

    printVariableAtomTable(atoms, numAtoms, terms, numTerms);

    return 0;
}

运行结果验证 #

修改后运行代码，输出将符合预期：

Table of Association between Variables and Elements:
Variable: A  B  
F: 4A  0B  
O: 24A  60B  
S: 6A  20B  
H: 0A  10B  
Na: 0A  B  

1. 栈结构替代递归：对于极深的嵌套结构，递归可能导致栈溢出，可以用栈保存每一层的乘数，遇到左括号压入当前乘数，遇到右括号弹出并乘以括号后的系数，迭代处理整个公式。
2. 原子符号哈希表：将原子符号存入哈希表（如基于ASCII的数组或自定义哈希函数），替代当前的线性查找，提升原子索引查找效率，尤其当原子数量较多时。
3. 预编译正则表达式：如果支持POSIX正则，可以用正则表达式匹配原子符号和系数，简化解析逻辑，但C标准库不支持正则，需要第三方库（如PCRE）。

内容的提问来源于stack exchange，提问作者Unsigned Index