C语言如何中序转前序

中序表达式如何转换为前序表达式

中序表达式转换为前序表达式的方法包括递归法、栈法、手动重写表达式等。本文将重点讨论递归法和使用栈的转换方法。 递归法通过递归调用函数来实现表达式的转换，适合处理树形结构；而栈法利用栈的特性，适合处理简单表达式和编译器设计。本文将详细介绍这两种方法的实现过程。

一、递归法

递归法通过递归调用函数，逐步将中序表达式转换为前序表达式。以下是详细步骤：

1、定义中序表达式

中序表达式是以操作数和操作符按一定顺序排列的表达式。例如，(A + B) * (C – D)。在中序表达式中，操作符在操作数之间。

2、定义树结构

定义一个树节点结构体，包含左子树、右子树和节点值。

typedef struct Node {
    char value;
    struct Node* left;
    struct Node* right;
} Node;

3、构建表达式树

递归地构建表达式树，每次找到当前子表达式中的操作符，分割子表达式。

Node* buildTree(char* expression, int start, int end) {
    // 基本情况：单个字符
    if (start == end) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->value = expression[start];
        node->left = node->right = NULL;
        return node;
    }
    // 找到操作符
    int op = findOperator(expression, start, end);
    Node* node = (Node*)malloc(sizeof(Node));
    node->value = expression[op];
    node->left = buildTree(expression, start, op - 1);
    node->right = buildTree(expression, op + 1, end);
    return node;
}

4、前序遍历树

前序遍历树（根-左-右），将节点值输出为前序表达式。

void preorder(Node* node) {
    if (node == NULL) return;
    printf("%c ", node->value);
    preorder(node->left);
    preorder(node->right);
}

5、完整程序示例

#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
    char value;
    struct Node* left;
    struct Node* right;
} Node;
int findOperator(char* expression, int start, int end) {
    // 简单示例，实际需要处理括号和优先级
    for (int i = end; i >= start; i--) {
        if (expression[i] == '+' || expression[i] == '-') return i;
    }
    return -1;
}
Node* buildTree(char* expression, int start, int end) {
    if (start == end) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->value = expression[start];
        node->left = node->right = NULL;
        return node;
    }
    int op = findOperator(expression, start, end);
    Node* node = (Node*)malloc(sizeof(Node));
    node->value = expression[op];
    node->left = buildTree(expression, start, op - 1);
    node->right = buildTree(expression, op + 1, end);
    return node;
}
void preorder(Node* node) {
    if (node == NULL) return;
    printf("%c ", node->value);
    preorder(node->left);
    preorder(node->right);
}
int main() {
    char expression[] = "A+B*C-D";
    Node* root = buildTree(expression, 0, 6);
    preorder(root);
    return 0;
}

二、栈法

栈法利用栈的后进先出特性，将中序表达式转换为前序表达式。以下是详细步骤：

1、初始化栈

定义一个栈结构体，包含栈数组和栈顶指针。

typedef struct Stack {
    char items[100];
    int top;
} Stack;
void push(Stack* stack, char value) {
    stack->items[++stack->top] = value;
}
char pop(Stack* stack) {
    return stack->items[stack->top--];
}
char peek(Stack* stack) {
    return stack->items[stack->top];
}
int isEmpty(Stack* stack) {
    return stack->top == -1;
}

2、定义优先级函数

定义一个函数，返回操作符的优先级。

int precedence(char op) {
    if (op == '+' || op == '-') return 1;
    if (op == '*' || op == '/') return 2;
    return 0;
}

3、中序转换为前序

遍历中序表达式，将操作数和操作符分别处理，使用栈存储操作符。

void infixToPrefix(char* expression) {
    Stack operators;
    operators.top = -1;
    char result[100];
    int k = 0;
    for (int i = 0; expression[i]; i++) {
        if (expression[i] >= 'A' && expression[i] <= 'Z') {
            result[k++] = expression[i];
        } else {
            while (!isEmpty(&operators) && precedence(peek(&operators)) >= precedence(expression[i])) {
                result[k++] = pop(&operators);
            }
            push(&operators, expression[i]);
        }
    }
    while (!isEmpty(&operators)) {
        result[k++] = pop(&operators);
    }
    result[k] = '';
    printf("Prefix Expression: %sn", result);
}

4、完整程序示例

#include <stdio.h>
#include <stdlib.h>
typedef struct Stack {
    char items[100];
    int top;
} Stack;
void push(Stack* stack, char value) {
    stack->items[++stack->top] = value;
}
char pop(Stack* stack) {
    return stack->items[stack->top--];
}
char peek(Stack* stack) {
    return stack->items[stack->top];
}
int isEmpty(Stack* stack) {
    return stack->top == -1;
}
int precedence(char op) {
    if (op == '+' || op == '-') return 1;
    if (op == '*' || op == '/') return 2;
    return 0;
}
void infixToPrefix(char* expression) {
    Stack operators;
    operators.top = -1;
    char result[100];
    int k = 0;
    for (int i = 0; expression[i]; i++) {
        if (expression[i] >= 'A' && expression[i] <= 'Z') {
            result[k++] = expression[i];
        } else {
            while (!isEmpty(&operators) && precedence(peek(&operators)) >= precedence(expression[i])) {
                result[k++] = pop(&operators);
            }
            push(&operators, expression[i]);
        }
    }
    while (!isEmpty(&operators)) {
        result[k++] = pop(&operators);
    }
    result[k] = '';
    printf("Prefix Expression: %sn", result);
}
int main() {
    char expression[] = "A+B*C-D";
    infixToPrefix(expression);
    return 0;
}

三、手动重写表达式

手动重写表达式是一种直观的方法，适用于简单表达式和教学演示。以下是详细步骤：

1、定义操作符优先级

定义操作符优先级，以便在重写表达式时遵循优先级规则。

int precedence(char op) {
    if (op == '+' || op == '-') return 1;
    if (op == '*' || op == '/') return 2;
    return 0;
}

2、重写表达式

逐步重写表达式，按照操作符优先级和括号规则，将中序表达式转换为前序表达式。

void infixToPrefix(char* expression) {
    // 处理括号和优先级
    // 逐步重写表达式
}

四、总结

中序表达式转换为前序表达式的方法包括递归法、栈法和手动重写表达式。递归法适合处理树形结构，栈法适合处理简单表达式和编译器设计，手动重写表达式适用于简单表达式和教学演示。 通过本文的介绍，希望读者能够掌握这几种方法，并能够在实际应用中选择合适的方法进行表达式转换。