【数据结构】将中缀表达式转化为后缀表达式

一、首先是将中缀表达式转换成后缀表达式的方法：

1、遇到操作数：直接输出（添加到后缀表达式中）

2、栈为空时，遇到运算符，直接入栈

3、遇到左括号：将其入栈

4、遇到右括号：执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出

5、遇到其他运算符：加减乘除：弹出所有优先级大于或者等于该运算符的栈顶元素，然后将该运算符入栈

6、最终将栈中的元素依次出栈，输出

//实现栈的数据结构
typedef struct Node
{
    char data;
    struct Node *next;
}node;
 
node *ini_node()
{
    //初始化栈，如果成功返回栈顶指针，失败返回0
    node *p;
    p = (node *)malloc(sizeof(node));
    if(p == NULL)
        return 0;
    else
    {
        p->next = NULL;
        return p;
    }
}
 
int push_node(node *top,char e)
{
    //压栈，top为栈顶指针，e为压入的数据
    //返回 0 为内存分配失败
    //返回 1 为压栈成功，返回 2 为传入字符非法
    if(e < 0 && e > 255)
        return 2;
    node *p;
    p = (node *)malloc(sizeof(node));
    if(p == NULL)
        return 0;
    p->next = NULL;
    p->data = e;
    p->next = top->next;
    top->next = p;
    return 1;
}
 
char pop_node(node *top)
    //弹出一个元素
{
    if(top == NULL)
        return 0;
    node *p;
    char e;
    p = top->next;
    e = p->data;
    top->next = p->next;
    free(p);
    return e;
}

二、编写一个函数，返回运算符的优先级

在这里，运算符只有 +  -  *  /，我们规定 +  - 的优先级为1 ，*  / 的优先级为2，以方便比较。

具体代码：

int prior(char a)
{
    if(a == '+' || a == '-')
        return 1;
    if(a == '*' || a == '/')
        return 2;
}

int shift(char *a,node *n)
{
    int i = 0;
    while(1)
    {
        if(a[i] == '\0')  //遇到结束符
        {
            if(n->next == NULL)  //此时如果栈顶为空就返回
                return 1;
            else
            //如果栈不为空则将栈内所有元素出栈
            {
                while(n->next != NULL)
                {
                    printf("%c",pop_node(n));
                }
                return 1;
            }
        }
        else if(a[i]>=0x30 && a[i]<=0x39)
        //如果是数字则输出
        {
            printf("%c",a[i]);
            i++;
            continue;
        }
        else if(n->next == NULL)
        //如果不是数字，只能是运算符，判断此时堆栈有没有元素
        //如果堆栈没有元素，将运算符压入堆栈
        {
            push_node(n,a[i]);
            i++;
            continue;
        }
         
        else if(a[i] == '(')   //遇到左括号，直接压入堆栈
        {
            push_node(n,a[i]);
            i++;
            continue;
        }
        else if(a[i] == ')')   
        //遇到右括号，将堆栈中的元素弹出并输出，直到遇到左括号，最后将左括号弹出
        //左括号不输出
        {
            while(n->next->data != '(')
                printf("%c",pop_node(n));
            pop_node(n);
            i++;
            continue;
        }
        else
        //既不是左括号，也不是右括号，堆栈也不为空
        //那么比较运算符与栈顶元素的优先级
        {
            while(1)
            {
                if(n->next == NULL || prior(a[i]) > prior(n->next->data) || n->next->data == '(')
                //如果栈顶为空或者优先级大于栈顶元素或者栈顶元素是左括号
                //那么将元素压入堆栈
                {
                    push_node(n,a[i]);
                    break;
                }
                else
                {
                    printf("%c",pop_node(n));  //弹出一个元素并输出
                }
            }
            i++;
            continue;
        }  
    }
 
    return 1;
}

int shift(char *a,node *n)
{
    int i = 0;
    while(1)
    {
        if(a[i] == '\0')  //遇到结束符
        {
            if(n->next == NULL)  //此时如果栈顶为空就返回
                return 1;
            else
            //如果栈不为空则将栈内所有元素出栈
            {
                while(n->next != NULL)
                {
                    printf("%c",pop_node(n));
                }
                return 1;
            }
        }
        else if(a[i]>=0x30 && a[i]<=0x39)
        //如果是数字则输出
        {
            printf("%c",a[i]);
            i++;
            continue;
        }
        else if(n->next == NULL)
        //如果不是数字，只能是运算符，判断此时堆栈有没有元素
        //如果堆栈没有元素，将运算符压入堆栈
        {
            push_node(n,a[i]);
            i++;
            continue;
        }
         
        else if(a[i] == '(')   //遇到左括号，直接压入堆栈
        {
            push_node(n,a[i]);
            i++;
            continue;
        }
        else if(a[i] == ')')   
        //遇到右括号，将堆栈中的元素弹出并输出，直到遇到左括号，最后将左括号弹出
        //左括号不输出
        {
            while(n->next->data != '(')
                printf("%c",pop_node(n));
            pop_node(n);
            i++;
            continue;
        }
        else
        //既不是左括号，也不是右括号，堆栈也不为空
        //那么比较运算符与栈顶元素的优先级
        {
            while(1)
            {
                if(n->next == NULL || prior(a[i]) > prior(n->next->data) || n->next->data == '(')
                //如果栈顶为空或者优先级大于栈顶元素或者栈顶元素是左括号
                //那么将元素压入堆栈
                {
                    push_node(n,a[i]);
                    break;
                }
                else
                {
                    printf("%c",pop_node(n));  //弹出一个元素并输出
                }
            }
            i++;
            continue;
        }  
    }
 
    return 1;
}