表达式求值

实验5  表达式求值

实验目的

1．  会定义顺序栈和链栈的结点类型。

2．  掌握栈的插入和删除结点在操作上的特点。

3．  熟悉对栈的一些基本操作和具体的函数定义。

实验内容

程序1

该程序的功能是实现顺序栈的定义和操作。该程序包括定义的栈结构类型以及对每一种栈操作的具体的函数定义和主函数。

/* 定义DataType为int类型 */

typedef int DataType;

 

/* 栈的结点类型 */

#define MAXSIZE  1024  

typedef  struct

{DataType  data[MAXSIZE];

int  top;

}SeqStack;

 

/* 初始化顺序栈 */

SeqStack  SeqStackInit()

 

/* 检查顺序栈是否为空 */

int SeqStackEmpty(SeqStack S)

 

/* 把S置为空栈 */

void ClearStack(SeqStack  S)

 

/* 把元素x压入栈，使其成为新的栈顶元素 */

void SeqStackPush(SeqStack S,DataType x)

 

/* 把栈顶元素弹出 */

DataType SeqStackPop(SeqStack S)

 

/* 取栈顶元素 */

DataType SeqStackGetTop(SeqStack S)

 

/*输出顺序栈中的元素*/

void SeqStackPrint(SeqStack S)

 

程序2 用顺序栈实现算术表达式求值。

将表达式看成字符串序列，输入语法正确、不含有变量的整数表达式（表达式中的数字限为单位数），利用算符的优先关系，把中序表达式转换为后序表达式后输出，然后求出该后序表达式的值。

例如：输入的表达式为2*(6-4)+8/4

转换后得到的后序表达式为264-*84/+

设计要求：在程序中构造六个子程序分别为

int empty(SeqStack stack); /*检查栈是否为空*/

int operation(char op); /*判断是否为运算符*/

int priority(char op); /*判断运算符的优先权*/

SeqStack push(SeqStack stack,char value); /*入栈*/

SeqStack pop(SeqStack stack,char *value); /*出栈*/

double count(char *backorder); /*计算逆波兰表达式的值*/

 

程序3 用链栈实现算术表达式求值。（与程序2的基本要求相同）

链栈结点的类型描述如下：

typedef int DataType;

typedef  struct StackNode

{DataType data;

struct StackNode *next;

}StackNode，*LinkedStack; 

“运算符优先级表” - 参考博客：http://www.jb51.net/article/37289.htm

/* 程序1
该程序的功能是实现顺序栈的定义和操作。该程序包括定义的栈结构类型以及对每一种栈操作的具体的函数定义和主函数。
*/
#include <stdio.h>
#include <stdlib.h>
/* 定义DataType为int类型 */
typedef int DataType;
 
/* 栈的结点类型 */
#define MAXSIZE  1024  
typedef  struct{
    DataType  data[MAXSIZE];
    int  top;
}SeqStack;
 
/* 初始化顺序栈 */
SeqStack  SeqStackInit()
{
    SeqStack q;
    q.top = -1;
    return q;
}
 
/* 检查顺序栈是否为空 */
int SeqStackEmpty(SeqStack S)
{
    if(S.top==-1)    //栈空
        return 1;
    else 
        return 0;
}
 
/* 把S置为空栈 */
void ClearStack(SeqStack  &S)
{
    S.top = -1;
}
 
/* 把元素x压入栈，使其成为新的栈顶元素 */
void SeqStackPush(SeqStack &S,DataType x)
{
    if(S.top==MAXSIZE-1)    //已经满了
        printf("入栈失败，栈已满！
");
    else {
        S.top++;
        S.data[S.top] = x;
    }
}
 
/* 把栈顶元素弹出 */
DataType SeqStackPop(SeqStack &S)
{
    if(S.top==-1){    //栈已空
        printf("出栈失败，栈已空！
");
        return 0;
    }
    else {
        DataType x = S.data[S.top--];
        return x;
    }
}
 
/* 取栈顶元素 */
DataType SeqStackGetTop(SeqStack S)
{
    return S.data[S.top];
}
 
/*输出顺序栈中的元素*/
void SeqStackPrint(SeqStack S)
{
    int top = S.top;
    while(top!=-1)
        printf("%d
",S.data[top--]);
}

int Menu()    //显示菜单，返回命令
{
    int in;
    printf("[1] 检查顺序栈是否为空
");
    printf("[2] 把S置为空栈
");
    printf("[3] 把元素x压入栈，使其成为新的栈顶元素
");
    printf("[4] 把栈顶元素弹出
");
    printf("[5] 取栈顶元素
");
    printf("[6] 输出顺序栈中的元素
");
    printf("[0] 按其它键退出
");
    scanf("%d",&in);
    return in;
}
void Reply(int in,SeqStack &S)    //对命令的反应
{
    int x;
    switch(in){
    case 1:
        if(SeqStackEmpty(S))
            printf("栈为空！
");
        else 
            printf("栈未空！
");
        break;
    case 2:
        ClearStack(S);    //将S置为空栈
        printf("已成功置为空栈！
");
        break;
    case 3:
        printf("请输入你要压栈的元素：
");
        scanf("%d",&x);
        SeqStackPush(S,x);
        break;
    case 4:
        SeqStackPop(S);
        break;
    case 5:
        if(SeqStackEmpty(S))
            printf("栈当前为空，栈顶无元素！
");
        else
            printf("栈顶元素为：%d
",SeqStackGetTop(S));
        break;
    case 6:
        if(SeqStackEmpty(S))
            printf("栈当前为空！
");
        else{ 
            printf("栈中元素为（从顶至下）：
");
            SeqStackPrint(S);
        }
        break;
    default:
        exit(1);
    }
    system("pause");
    system("cls");
}
int main()
{
    SeqStack S = SeqStackInit();
    while(1){
        int in = Menu();
        Reply(in,S);
    }
    return 0;
}

/* 程序2 用顺序栈实现算术表达式求值。
将表达式看成字符串序列，输入语法正确、不含有变量的整数表达式（表达式中的数字限为单位数）
利用算符的优先关系，把中序表达式转换为后序表达式后输出，然后求出该后序表达式的值。
例如：输入的表达式为2*(6-4)+8/4
转换后得到的后序表达式为264-*84/+
设计要求：在程序中构造六个子程序分别为
*/
#include <stdio.h>
#include <stdlib.h>
/* 定义DataType为int类型 */
typedef char DataType;
 
/* 栈的结点类型 */
#define MAXSIZE  1024  
typedef  struct{
    char data[MAXSIZE];
    int  top;
}SeqStack;
SeqStack op;    //运算符栈和表达式栈

int Prior[6][6] =    //Prior[lop][rop]
{ // 运算符优先级表 
 // '+' '-' '*' '/' '(' ')'
 /*'+'*/-1,-1,1,1,1,-1,
 /*'-'*/-1,-1,1,1,1,-1,
 /*'*'*/-1,-1,-1,-1,1,-1,
 /*'/'*/-1,-1,-1,-1,1,-1,
 /*'('*/1,1,1,1,1,0,
 /*')'*/-1,-1,-1,-1,0,-1
};

int empty(SeqStack stack) /*检查栈是否为空*/
{
    if(stack.top==-1)    //栈空
        return 1;
    else 
        return 0;
}
int operation(char op) /*判断是否为运算符*/
{
    if('0'<=op && op<='9')    //是单位数字，不是运算符
        return 0;
    else 
        return 1;
}
int priority(char rop) /*判断运算符的优先权*/
{
    char lop = op.data[op.top];
    int a,b;
    switch(lop){
    case '+':a=0;break;
    case '-':a=1;break;
    case '*':a=2;break;
    case '/':a=3;break;
    case '(':a=4;break;
    case ')':a=5;break;
    default:break;
    }
    switch(rop){
    case '+':b=0;break;
    case '-':b=1;break;
    case '*':b=2;break;
    case '/':b=3;break;
    case '(':b=4;break;
    case ')':b=5;break;
    default:break;
    }
    return Prior[a][b];
}
SeqStack push(SeqStack stack,char value) /*入栈*/
{
    if(stack.top==MAXSIZE-1)    //已经满了
        printf("入栈失败，栈已满！
");
    else {
        stack.top++;
        stack.data[stack.top] = value;
    }
    return stack;
}
SeqStack pop(SeqStack stack,char *value) /*出栈*/
{
    if(stack.top==-1){    //栈已空
        printf("出栈失败，栈已空！
");
        return stack;
    }
    else {
        *value = stack.data[stack.top--];
        return stack;
    }
}
double count(char *backorder) /*计算逆波兰表达式的值*/
{
    struct {
        double data[MAXSIZE];
        int top;
    } ds;    //数栈
    ds.top = -1;
    int i;
    for(i=0;backorder[i];i++)
        if(operation(backorder[i])){    //是运算符
            double a,b;
            b = ds.data[ds.top--];    //从数栈中依次取出两个数
            a = ds.data[ds.top--];
            switch(backorder[i]){    //运算并入栈
            case '+':ds.top++;ds.data[ds.top] = a+b;break;
            case '-':ds.top++;ds.data[ds.top] = a-b;break;
            case '*':ds.top++;ds.data[ds.top] = a*b;break;
            case '/':ds.top++;ds.data[ds.top] = a/b;break;
            default:break;
            }
        }
        else{    //是数，直接入数栈
            ds.top++;
            ds.data[ds.top] = double(backorder[i] - '0');
        }
    return ds.data[ds.top];
}
void trans(char exp[],char backorder[])    //将中序表达式转换成后缀表达式，存储一字符串中
{
    int index=0;
    int len = 0;
    while(exp[index]){
        if(operation(exp[index])){    //是运算符
            if(empty(op)){    //如果运算符栈为空，直接入栈
                op = push(op,exp[index++]);
            }
            else{    //运算符栈不为空，与将该运算符与栈顶运算符比较
                char c;
                switch(priority(exp[index])){
                case 1:    //当前运算符比栈顶运算符优先级高
                    op = push(op,exp[index++]);
                    break;
                case 0:    //运算符优先级相等。只出现在栈顶为'('和当前为')'的情况
                    op = pop(op,&c);
                    index++;
                    break;
                case -1:    //当前运算符优先级低
                    op = pop(op,&c);    //退栈 
                    backorder[len++] = c;    //将运算符放入字符串中
                    break;
                default:break;
                }
            }
        }
        else{    //是数字。直接压栈
            backorder[len++] = exp[index++];    //将数字放入字符串中
        }
    }
    while(!empty(op)){    //如果运算符栈不为空，全部出栈
        char c;
        op = pop(op,&c);    //退栈 
        backorder[len++] = c;    //将运算符放入字符串中
    }
    backorder[len] = '';
}
void print(char backorder[])    //输出表达式栈中的式子
{
    int i;
    for(i=0;backorder[i];i++)
        printf("%c",backorder[i]);
    printf("
");
}
int main()
{
    char exp[MAXSIZE];
    char backorder[MAXSIZE];
    printf("[1] 请输入中缀表达式：
");
    while(scanf("%s",exp)!=EOF){
        //初始化
        op.top = -1;
        //输出转换后的后缀表达式
        trans(exp,backorder);
        printf("[2] 其后缀表达式为：
");
        print(backorder);
        //计算后缀表达式的结果
        printf("[3] 后缀表达式的结果：
");
        printf("%lf
",count(backorder));
        //为下一次输入做准备
        printf("
");
        printf("请输入中缀表达式：
");
    }
    return 0;
}

/* 程序3 用链栈实现算术表达式求值。（与程序2的基本要求相同）
*/
#include <stdio.h>
#include <stdlib.h>

/* 栈的结点类型 */
#define MAXSIZE  1024

//链栈结点的类型描述如下：
typedef char DataType;
typedef  struct StackNode{
    DataType data;
    struct StackNode *next;
} StackNode,*LinkedStack;

LinkedStack op;    //运算符栈和表达式栈

int Prior[6][6] =    //Prior[lop][rop]
{ // 运算符优先级表 
 // '+' '-' '*' '/' '(' ')'
 /*'+'*/-1,-1,1,1,1,-1,
 /*'-'*/-1,-1,1,1,1,-1,
 /*'*'*/-1,-1,-1,-1,1,-1,
 /*'/'*/-1,-1,-1,-1,1,-1,
 /*'('*/1,1,1,1,1,0,
 /*')'*/-1,-1,-1,-1,0,-1
};

int empty(LinkedStack &stack) /*检查栈是否为空*/
{
    if(stack->next==NULL)    //栈空
        return 1;
    else
        return 0;
}
int operation(char op) /*判断是否为运算符*/
{
    if('0'<=op && op<='9')    //是单位数字，不是运算符
        return 0;
    else 
        return 1;
}
int priority(char rop) /*判断运算符的优先权*/
{
    char lop = op->next->data;
    int a,b;
    switch(lop){
    case '+':a=0;break;
    case '-':a=1;break;
    case '*':a=2;break;
    case '/':a=3;break;
    case '(':a=4;break;
    case ')':a=5;break;
    default:break;
    }
    switch(rop){
    case '+':b=0;break;
    case '-':b=1;break;
    case '*':b=2;break;
    case '/':b=3;break;
    case '(':b=4;break;
    case ')':b=5;break;
    default:break;
    }
    return Prior[a][b];
}
LinkedStack push(LinkedStack &stack,char value) /*入栈*/
{
    LinkedStack p = (LinkedStack)malloc(sizeof(StackNode));
    p->data = value;
    p->next = stack->next;
    stack->next = p;
    return stack;
}
LinkedStack pop(LinkedStack &stack,char *value) /*出栈*/
{
    if(stack->next==NULL){    //栈已空
        printf("出栈失败，栈已空！
");
        return stack;
    }
    else {
        LinkedStack p = stack->next;
        stack->next = p->next;
        *value = p->data;
        free(p);
        return stack;
    }
}
double count(char *backorder) /*计算逆波兰表达式的值*/
{
    typedef struct DigitStack{
        double data;
        DigitStack *next;
    } DigitStack,*LinkedDS;    //数栈
    LinkedDS ds = (LinkedDS)malloc(sizeof(DigitStack));
    LinkedDS p;
    ds->next = NULL;    //初始化
    int i;
    for(i=0;backorder[i];i++)
        if(operation(backorder[i])){    //是运算符
            double a,b;
            p = ds->next;    //从数栈中依次取出两个数
            ds->next = p->next;
            b = p->data;
            free(p);
            p = ds->next;
            ds->next = p->next;
            a = p->data;
            free(p);
            p = (LinkedDS)malloc(sizeof(DigitStack));
            switch(backorder[i]){    //运算并入栈
            case '+':
                p->data = a+b;
                p->next = ds->next;
                ds->next = p;
                break;
            case '-':
                p->data = a-b;
                p->next = ds->next;
                ds->next = p;
                break;
            case '*':
                p->data = a*b;
                p->next = ds->next;
                ds->next = p;
                break;
            case '/':
                p->data = a/b;
                p->next = ds->next;
                ds->next = p;
                break;
            default:break;
            }
        }
        else{    //是数，直接入数栈
            p = (LinkedDS)malloc(sizeof(DigitStack));
            p->data = double(backorder[i] - '0');
            p->next = ds->next;
            ds->next = p;
        }
    return ds->next->data;
}
void trans(char exp[],char backorder[])    //将中序表达式转换成后缀表达式，存储一字符串中
{
    int index=0;
    int len = 0;
    while(exp[index]){
        if(operation(exp[index])){    //是运算符
            if(empty(op)){    //如果运算符栈为空，直接入栈
                op = push(op,exp[index++]);
            }
            else{    //运算符栈不为空，与将该运算符与栈顶运算符比较
                char c;
                switch(priority(exp[index])){
                case 1:    //当前运算符比栈顶运算符优先级高
                    op = push(op,exp[index++]);
                    break;
                case 0:    //运算符优先级相等。只出现在栈顶为'('和当前为')'的情况
                    op = pop(op,&c);
                    index++;
                    break;
                case -1:    //当前运算符优先级低
                    op = pop(op,&c);    //退栈 
                    backorder[len++] = c;    //将运算符放入字符串中
                    break;
                default:break;
                }
            }
        }
        else{    //是数字。直接压栈
            backorder[len++] = exp[index++];    //将数字放入字符串中
        }
    }
    while(!empty(op)){    //如果运算符栈不为空，全部出栈
        char c;
        op = pop(op,&c);    //退栈 
        backorder[len++] = c;    //将运算符放入字符串中
    }
    backorder[len] = '';
}
void print(char backorder[])    //输出表达式栈中的式子
{
    int i;
    for(i=0;backorder[i];i++)
        printf("%c",backorder[i]);
    printf("
");
}
void Destroy(LinkedStack &op)
{
    while(op->next){
        LinkedStack p = op->next;
        op->next = p->next;
        free(p);
    }
}
int main()
{
    char exp[MAXSIZE];
    char backorder[MAXSIZE];
    op = (LinkedStack)malloc(sizeof(StackNode));
    printf("[1] 请输入中缀表达式：
");
    while(scanf("%s",exp)!=EOF){
        //初始化
        op->next = NULL;
        //输出转换后的后缀表达式
        trans(exp,backorder);
        printf("[2] 其后缀表达式为：
");
        print(backorder);
        //计算后缀表达式的结果
        printf("[3] 后缀表达式的结果：
");
        printf("%lf
",count(backorder));
        //为下一次输入做准备
        Destroy(op);
        printf("
");
        printf("请输入中缀表达式：
");
    }
    return 0;
}