C语言实现化学方程式配平

下面是一个简单的C语言程序，用于实现化学方程式的配平：

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

#define MAX_ELEMENT_NUM 10
#define MAX_REACTION_NUM 10

typedef struct Reaction {
    int reactants[MAX_ELEMENT_NUM];
    int products[MAX_ELEMENT_NUM];
} Reaction;

int get_element_index(char *element, char **elements, int element_num) {
    for (int i = 0; i < element_num; i++) {
        if (strcmp(element, elements[i]) == 0) {
            return i;
        }
    }
    return -1;
}

void parse_reaction(char *reaction_str, char **elements, int element_num, Reaction *reaction) {
    int i = 0;
    char *token = strtok(reaction_str, "->");
    while (token != NULL) {
        char *element = strtok(token, "+");
        while (element != NULL) {
            int coefficient = 1;
            if (element[0] >= '0' && element[0] <= '9') {
                coefficient = atoi(element);
                element++;
            }
            int idx = get_element_index(element, elements, element_num);
            if (i == 0) {
                reaction->reactants[idx] += coefficient;
            } else {
                reaction->products[idx] += coefficient;
            }
            element = strtok(NULL, "+");
        }
        token = strtok(NULL, "->");
        i++;
    }
}

void print_reaction(char **elements, int element_num, Reaction *reaction) {
    for (int i = 0; i < element_num; i++) {
        if (reaction->reactants[i] != 0) {
            printf("%d%s", reaction->reactants[i], elements[i]);
            if (i < element_num - 1) {
                printf(" + ");
            }
        }
    }
    printf(" -> ");
    for (int i = 0; i < element_num; i++) {
        if (reaction->products[i] != 0) {
            printf("%d%s", reaction->products[i], elements[i]);
            if (i < element_num - 1) {
                printf(" + ");
            }
        }
    }
    printf("\n");
}

void swap_rows(double **matrix, int i, int j, int n) {
    double *tmp = malloc(n * sizeof(double));
    memcpy(tmp, matrix[i], n * sizeof(double));
    memcpy(matrix[i], matrix[j], n * sizeof(double));
    memcpy(matrix[j], tmp, n * sizeof(double));
    free(tmp);
}

int gaussian_elimination(double **matrix, int m, int n) {
    int rank = 0;
    for (int i = 0; i < n; i++) {
        int pivot_row = rank;
        for (int j = rank + 1; j < m; j++) {
            if (matrix[j][i] > matrix[pivot_row][i]) {
                pivot_row = j;
            }
        }
        if (matrix[pivot_row][i] == 0) {
            continue;
        }
        if (pivot_row != rank) {
            swap_rows(matrix, rank, pivot_row, n);
        }
        for (int j = rank + 1; j < m; j++) {
            double factor = matrix[j][i] / matrix[rank][i];
            for (int k = i; k < n; k++) {
                matrix[j][k] -= factor * matrix[rank][k];
            }
        }
        rank++;
    }
    return rank;
}

void back_substitution(double **matrix, int rank, int n) {
    for (int i = rank - 1; i >= 0; i--) {
        for (int j = i - 1; j >= 0; j--) {
            double factor = matrix[j][i] / matrix[i][i];
            for (int k = i; k < n; k++) {
                matrix[j][k] -= factor * matrix[i][k];
            }
        }
    }
}

void balance_equation(char **elements, int element_num, Reaction *reaction) {
    double **matrix = malloc(element_num * sizeof(double *));
    for (int i = 0; i < element_num; i++) {
        matrix[i] = calloc(element_num + 1, sizeof(double));
        matrix[i][i] = 1;
    }
    for (int i = 0; i < element_num; i++) {
        for (int j = 0; j < element_num; j++) {
            matrix[i][j] = reaction->reactants[j] - reaction->products[j];
        }
    }
    int rank = gaussian_elimination(matrix, element_num, element_num + 1);
    back_substitution(matrix, rank, element_num + 1);
    for (int i = 0; i < element_num; i++) {
        int coefficient = (int)(matrix[i][element_num] + 0.5);
        reaction->reactants[i] *= coefficient;
        reaction->products[i] *= coefficient;
    }
    for (int i = 0; i < element_num; i++) {
        free(matrix[i]);
    }
    free(matrix);
}

int main() {
    char *elements[MAX_ELEMENT_NUM] = {"H", "O", "N", "C", "Cl", "K"};
    int element_num = 6;
    char *reactions[MAX_REACTION_NUM] = {"H2 + O2 -> H2O", "NH3 + O2 -> NO + H2O", "C2H5OH + O2 -> CO2 + H2O", "SO2 + O2 -> SO3", "KClO3 -> KCl + O2"};
    int reaction_num = 5;
    Reaction reaction;
    for (int i = 0; i < reaction_num; i++) {
        parse_reaction(reactions[i], elements, element_num, &reaction);
        balance_equation(elements, element_num, &reaction);
        printf("Balanced reaction: ");
        print_reaction(elements, element_num, &reaction);
    }
    return 0;
}

该程序首先定义了元素和反应式的结构体，然后通过`parse_reaction`函数将输入的化学方程式转换成元素-反应物矩阵，接着使用高斯-约旦消元法计算出矩阵的秩和解，最后将解应用到反应式上，输出配平后的反应式。

在本程序中，我们定义了一个简单的元素和反应式表，可以在其中添加和修改元素和反应式。同时，该程序也可以处理多个反应式，输出它们配平后的结果。