逆波兰表达式模型

　　其实这个东西早在7月开始的时候我就写好了，本来想等小师妹写好了她的版本再放到网上的。。。无奈她写的实在是太慢了。这个东西还是有改进的空间的，比如升级成浮点模型啥的。

　　逆波兰表达式的可以以O（N）时间复杂度处理任意表达式，其实也叫后缀表达式，中缀表达式（就是我们一般看到的表达式（1+1=2）），处理的时候分两个栈，一个符号栈，一个表达式栈：

　　（注意我只选二元运算符为例，只处理+-*/和括号）

　　1. 如果遇到数字，压入表达式栈

　　2. 如果遇到符号

　　　　a. 如果符号是左括号，则直接压入符号栈

　　　　b. 如果是*/符号，且符号栈顶符号为+-或者( ，那么直接压入当前符号即可；如果符号栈顶为*/，弹出符号栈顶符号到表达式栈，压入当前符号。

　　　　c. 如果是+-号，如果符号栈栈顶是*/，则pop符号栈顶到最近的+-号或者（；如果是+-或者（，那就直接弹出上一个+/-号然后压入当前+/-号。

　　　　d. 遇到）就pop符号栈到（

　　　　e. 如果把中缀表达式扫完了符号栈还有东西，那么将符号栈的东西全部pop到表达式栈。

　　

　　后缀转中缀是上面的逆过程，看代码就知道了。

　　之前有想过改成C++的，但是那段时间忙着出Qt，就没写了，这以后可能每三天就写个算法或者复习下以前的数据结构，备战下下一年的面试，就酱~

　　以后博客的名字就不分类型拉~感觉直接分类更快。

//main.c

#include <stdio.h>
#include "plug.h"
#include "stack.h"
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>

int main(int argc, char *argv[])
{
    int error_exp = 0;
    char symnum[81] = { '' };
    FILE *fp_in = fopen("D:\input.txt", "r");
    FILE *fp_out = fopen("D:\output.txt", "w");
    if (fp_in == NULL)
        exit(1);

    while (!feof(fp_in))
    {
        fscanf(fp_in, "%s", symnum);
        fprintf(fp_out, " Infix expression:  %s
", symnum);
        error_exp += scan_Infix_to_Suffix(symnum, fp_out);
        fprintf(fp_out, "
");
    }
    fprintf(fp_out, "
Sum of error expression: %d
", error_exp);

    return EXIT_SUCCESS;
}

int scan_Infix_to_Suffix(char *input, FILE *fp)
{
    int i = 0;
    Stack_manager *num_stack = allcoate_stack_man(),
                  *stack_man = allcoate_stack_man(),
                  *sym_man = allcoate_stack_man();
    Stack **list = (Stack **)malloc(sizeof(Stack)*MAX);//存指向栈的指针的表

    for (;input[i]!='';i++)
    {
        if (input[i] >= '0' && input[i] <= '9')
            //把所有连续的数字先结合起来形成一个数，如果遇到符号，则把num栈转化为数字存入主栈中
            push_in_int(num_stack, input[i] - '0');
        //遇到'('，优先级最高，直接压栈
        else if (input[i] == '(')
            push_in_char(sym_man, input[i]);
        else if (input[i] == '*' || input[i] == '/')
        {
            //遇到乘除号，如果栈中含有（'+'或者'-'），压入符号栈
            if (input[i - 1] != ')')
                push_in_int(stack_man, combine_Stack_to_Num(num_stack));

            //错误处理
            if ((stack_man->top->type == is_int && input[i] == '/')//除数不能为0
                || i == 0                                           //开头出现单独乘除号
                || input[i - 1] == '+' || input[i - 1] == '-'       //两个符号连续
                || input[i - 1] == '*' || input[i - 1] == '/'
                )
            {
                error(sym_man, stack_man, num_stack, list, fp);
                return 1;
            }

            if (sym_man->top == NULL
                || (sym_man->top->sym == '+' || sym_man->top->sym == '-')
                && sym_man->top->sym == '(')
                //除非处理闭括号，否则看到'('什么符号都压栈
                push_in_char(sym_man, input[i]);

            //否则弹出上一个乘除号
            else if (sym_man->top->sym == '*' || sym_man->top->sym == '/')
            {
                push_in_char(stack_man, sym_man->top->sym);
                pop_out(sym_man);
                push_in_char(sym_man, input[i]);
            }
        }
        else if (input[i] == '+' || input[i] == '-')
        {
            if (input[i - 1] != '(' && input[i - 1] != ')' && i != 0)
                push_in_int(stack_man, combine_Stack_to_Num(num_stack));

            //错误处理（开头连续两个加减号或者连续三个符号）
            if (i == 1 && (input[i - 1] == '+' || input[i - 1] == '-'))
            {
                error(sym_man, stack_man, num_stack, list, fp);
                return 1;
            }
            if (i >= 2 && (input[i - 1] == '+' || input[i - 1] == '-')
                && (input[i - 2] == '+' || input[i - 1] == '-' || input[i - 1] == '*' || input[i - 1] == '/'
                || input[i - 1] == '(' || input[i - 1] == ')'))
            {
                error(sym_man, stack_man, num_stack, list, fp);
                return 1;
            }

            //如果前一个为符号或者左括号或者没有符号，则为数的正负，压入数栈
            if (i == 0
                || input[i - 1] == '+' || input[i - 1] == '-'
                || input[i - 1] == '*' || input[i - 1] == '/'
                || input[i - 1] == '(')
                push_in_char(num_stack, input[i]);

            //如果有比+-优先级更高的运算符（'*','/'），则把符号弹出直到上一次的加减号或者'('为止
            else if (!sym_man->top
                || sym_man->top->sym == '*' || sym_man->top->sym == '/'
                || sym_man->top->sym == '(')//符号为'('的情况合并到这里了
            {
                for (;sym_man->top != NULL
                    && sym_man->top->sym != '(';)
                {
                    push_in_char(stack_man, sym_man->top->sym);
                    pop_out(sym_man);
                }
                push_in_char(sym_man, input[i]);
            }
            //如果上一个符号是+-号，那么直接弹出上一个加减号到主栈，并且把当前符号压入符号栈
            else if (sym_man->top->sym == '+' || sym_man->top->sym == '-')
            {
                push_in_char(stack_man, sym_man->top->sym);
                pop_out(sym_man);
                push_in_char(sym_man, input[i]);
            }
        }
        else if (input[i] == ')')
        {
            push_in_int(stack_man, combine_Stack_to_Num(num_stack));

            for (;sym_man->top != NULL && sym_man->top->sym != '(';)
            {
                push_in_char(stack_man, sym_man->top->sym);
                pop_out(sym_man);
            }
            if (sym_man->top->sym != '(')//只有右括号括号，出错
            {
                error(sym_man, stack_man, num_stack, list, fp);
                return 1;
            }
            pop_out(sym_man);//弹掉'('
        }
        else//其他情况均为不合法的情况，out
        {
            error(sym_man, stack_man, num_stack, list, fp);
            return 1;
        }
    }
    //最后应该还有一个数字的
    if (input[i - 1] != ')')
        push_in_int(stack_man, combine_Stack_to_Num(num_stack));

    //把剩下的符号弹入栈中
    for (;sym_man->top!=NULL;)
    {
        if (sym_man->top->sym == '(')//只有左括号，出错
        {
            error(sym_man, stack_man, num_stack, list, fp);
            return 1;
        }
        push_in_char(stack_man, sym_man->top->sym);
        pop_out(sym_man);
    }
    copy_Stack_to_List(list, stack_man);
    print_list(list, stack_man->node_sum, fp);
    caculate_Infix(list, stack_man->node_sum,fp);

    //正常退出
    delete_stack(&sym_man);
    delete_stack(&stack_man);
    delete_stack(&num_stack);
    free(list);
    return 0;
}

int combine_Stack_to_Num(Stack_manager *const num_stack)
{
    int sum = 0, num_pow = 0;
    for (;num_stack->top != NULL;)
    {
        if (num_stack->top->type == is_int)
            sum += (int)(num_stack->top->num*pow(10.0, (double)num_pow++));
        else
            sum = num_stack->top->sym == '+' ? sum : -sum;
        pop_out(num_stack);
    }
    return sum;
}

void copy_Stack_to_List(Stack **const list, Stack_manager *const stack_man)
{
    int j = stack_man->node_sum - 1;
    Stack *tmp = stack_man->top;
    for (;j != -1;j--, tmp = tmp->prev)
        list[j] = tmp;
}

void get_Ans(Stack_manager *const s, char operation)
{
    assert(s->top != NULL || s->top->prev != NULL);
    int tmp1 = s->top->num, tmp2 = s->top->prev->num, ans;
    if (operation == '+')
        ans = tmp1 + tmp2;
    else if (operation == '-')
        ans = tmp2 - tmp1;
    else if (operation == '*')
        ans = tmp1*tmp2;
    else if (operation == '/')
        ans = tmp2 / tmp1;
    //连续pop两次，把tmp1和tmp2弹出去
    pop_out(s); pop_out(s);
    //把答案压栈
    push_in_int(s, ans);
}

void print_list(Stack **const list, int const node_sum, FILE *fp)
{
    int i;
    fprintf(fp,"Suffix expression: ");
    for (i = 0;i < node_sum;i++)
    {
        if (list[i]->type == is_sym)
            fprintf(fp, "%c ", list[i]->sym);
        else
            fprintf(fp, "%d ", list[i]->num);
    }
    fprintf(fp,"
");
}

void caculate_Infix(Stack **const suffix_list, int const node_sum, FILE *fp)
{
    int i;
    Stack_manager *stack_man = allcoate_stack_man();
    for (i = 0;i < node_sum;i++)
    {
        if (suffix_list[i]->type == is_int)
            push_in_int(stack_man, suffix_list[i]->num);
        else if (suffix_list[i]->type == is_sym)
            get_Ans(stack_man, suffix_list[i]->sym);
    }
    fprintf(fp, "           Answer: %d
", stack_man->top->num);
    
    delete_stack(&stack_man);
}

void error(Stack_manager *s1, Stack_manager *s2, Stack_manager *s3, Stack**L,FILE *fp)
{
    fprintf(fp, "< illegal expression! >
");
    delete_stack(&s1);
    delete_stack(&s2);
    delete_stack(&s3);
    free(L);
}

//plug.h

#ifndef Suffix_to_Infix
#define Suffix_to_Infix
#define MAX 256
#include <stdio.h>

enum symbol_or_interget { is_sym, is_int };

typedef struct _stack
{
    char sym;
    int num, type;
    struct _stack *prev;
}Stack;

typedef struct _stack_manager
{
    int node_sum;
    struct _stack *top;
}Stack_manager;

void push_in_int(Stack_manager *const, const int);
void push_in_char(Stack_manager *const, const char);
void pop_out(Stack_manager *const);
int scan_Infix_to_Suffix(char *,FILE *);
int combine_Stack_to_Num(Stack_manager *const);
void copy_Stack_to_List(Stack **const, Stack_manager *const);
void caculate_Infix(Stack **const, int const, FILE *);
void get_Ans(Stack_manager *const, char);
void print_list(Stack **const,int const, FILE *);
void error(Stack_manager *, Stack_manager *, Stack_manager *, Stack**, FILE *fp);

#endif // !Suffix_to_Infix

//stack.cpp

#include "plug.h"
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>

Stack_manager *allcoate_stack_man(void)
{
    Stack_manager *stack_man = (Stack_manager *)malloc(sizeof(Stack_manager));
    stack_man->top = NULL, stack_man->node_sum = 0;
    return stack_man;
}

void push_in_int(Stack_manager *const s_head, const int item)
{
    Stack *tmp = NULL;
    
    tmp = (Stack *)malloc(sizeof(Stack));
    
    tmp->prev = s_head->top;
    tmp->num = item, tmp->sym = '';
    tmp->type = is_int;

    s_head->node_sum++;
    s_head->top = tmp;
}

void push_in_char(Stack_manager *const s_head, const char item)
{
    Stack *tmp = NULL;

    tmp = (Stack *)malloc(sizeof(Stack));

    tmp->prev = s_head->top;
    tmp->sym = item, tmp->num = 0;
    tmp->type = is_sym;

    s_head->node_sum++;
    s_head->top = tmp;
}

void pop_out(Stack_manager *const s)
{
    Stack *tmp = s->top->prev;
    s->node_sum--;
    free(s->top);
    s->top = tmp;
}

void delete_stack(Stack_manager **stack_man)
{
    for (;(*stack_man)->top != NULL;)
        pop_out(*stack_man);
    free(*stack_man);
    *stack_man = NULL;
}

void print_stack(Stack_manager *const s)
{
    Stack *tmp = s->top;
    for (;tmp != NULL;tmp = tmp->prev)
    {
        if (tmp->type == is_sym)
            printf("%c ", tmp->sym);
        else
            printf("%d ", tmp->num);
    }
    printf("
");
}

//stack.h

#ifndef STACK
#define STACK

void push_in_int(Stack_manager *const, const int);
void push_in_char(Stack_manager *const, const char);
void pop_out(Stack_manager *const);
Stack_manager *allcoate_stack_man(void);
void delete_stack(Stack_manager **);
void print_stack(Stack_manager *const);

#endif // !STACK