The stack and queue in C language implement instances of expression evaluation
- 2020-05-27 06:44:24
- OfStack
An instance of an expression evaluation implemented by a stack and a queue in the C language
Implementation code:
#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define STACK_SIZE 20
#define STACK_INCREMENT 10
#define QUEUE_SIZE 20
typedef int Status;
typedef char StackElemtype;
typedef struct Stack{
StackElemtype* base;
StackElemtype* top;
int stackSize;
}Stack;
Status StackInit(Stack* s){
s->base = (StackElemtype*)malloc(sizeof(StackElemtype) * STACK_SIZE);
if( !s->base )
return ERROR;
s->top = s->base;
s->stackSize = STACK_SIZE;
return OK;
}
Status Pop(Stack* s,StackElemtype* value){
if( s->base == s->top ){
printf("\nstack empty\n");
return ERROR;
}
*value = *(--(s->top));
return OK;
}
Status Push(Stack* s,StackElemtype value){
if( s->top - s->base == s->stackSize){
s->base = (StackElemtype*)realloc(s->base,sizeof(StackElemtype) * (STACK_INCREMENT + STACK_SIZE));
if( !s->base )
return ERROR;
s->top = s->base + STACK_SIZE;
s->stackSize = STACK_SIZE + STACK_INCREMENT;
}
*(s->top) = value;
s->top++;
return OK;
}
int StackLength(Stack s){
return s.top - s.base;
}
typedef double StackElemtype_ForValueExperssion;
typedef struct Stack_2{
StackElemtype_ForValueExperssion* base;
StackElemtype_ForValueExperssion* top;
int stackSize;
}Stack_2;
Status StackInit_2(Stack_2* s){
s->base = (StackElemtype_ForValueExperssion*)malloc(sizeof(StackElemtype_ForValueExperssion) * STACK_SIZE);
if( !s->base )
return ERROR;
s->top = s->base;
s->stackSize = STACK_SIZE;
return OK;
}
Status Pop_2(Stack_2* s,StackElemtype_ForValueExperssion* value){
if( s->base == s->top ){
printf("\nstack empty\n");
return ERROR;
}
*value = *(--(s->top));
return OK;
}
Status Push_2(Stack_2* s,StackElemtype_ForValueExperssion value){
if( s->top - s->base == s->stackSize){
s->base = (StackElemtype_ForValueExperssion*)realloc(s->base,sizeof(StackElemtype_ForValueExperssion) * (STACK_INCREMENT + STACK_SIZE));
if( !s->base )
return ERROR;
s->top = s->base + STACK_SIZE;
s->stackSize = STACK_SIZE + STACK_INCREMENT;
}
*(s->top) = value;
s->top++;
return OK;
}
typedef double QueueElemtype;
typedef char QueueOperatorValue;
typedef struct QueueNode{
QueueElemtype data;
QueueOperatorValue operator;
struct QueueNode* next;
int flag;
}QueueNode,*QueueNodePtr;
typedef struct Queue{
QueueNodePtr front;
QueueNodePtr rear;
}Queue;
Status QueueInit(Queue* q){
q->front = (QueueNodePtr)malloc(sizeof(QueueNode));
if( !q->front )
return ERROR;
q->rear = q->front;
q->rear->next = NULL;
return OK;
}
Status QueueInsert(Queue* q,QueueElemtype value){
QueueNodePtr new;
new = (QueueNodePtr)malloc(sizeof(QueueNode));
if( !new )
return ERROR;
new->data = value;
new->flag = 1;
new->next = NULL;
q->rear->next = new;
q->rear = new;
return OK;
}
Status QueueInsert_operatorValue(Queue* q,QueueOperatorValue value){
QueueNodePtr new;
new = (QueueNodePtr)malloc(sizeof(QueueNode));
if( !new )
return ERROR;
new->operator = value;
new->flag = 0;
new->next = NULL;
q->rear->next = new;
q->rear = new;
return OK;
}
Status QueueDelete(Queue* q,QueueElemtype* value,QueueOperatorValue *operator,int* symbol){
QueueNodePtr first;
if( q->front == q->rear )
return ERROR;
first = q->front->next;
if( first->flag == 1 ){
*value = first->data;
*symbol = 1;
}
else{
*operator = first->operator;
*symbol = 0;
}
q->front->next = first->next;
if( first == q->rear ){
q->rear = q->front;
}
return OK;
}
/* Use stack to convert infix expression into suffix expression:
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* | User input | Processing carried out |
* | 0~9 : | Output directly to the console |
* | / . * . ( | directly Push |
* | + . - | Will stack the elements Pop until 1. Stack empty or 2. encounter ( |
* | ) | In case of ( All the elements in the stack were previously added Pop |
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* */
Status Infix2Postfix(Queue* q){
//Queue q;
//QueueInit(&q);
Stack s;
StackInit(&s);
char c,e;
char bufferDigit[10];
int i = 0;
double longDigit;
printf(" Please Enter Infix Expression\n");
printf("------------NOTE: end of '#'--------------\n");
scanf("%c", &c);
while( '#' != c){
while( c <= '9' && c >= '0' || '.' == c ){
bufferDigit[i++] = c;
bufferDigit[i] = '\0';
scanf("%c", &c);
if(!((c <= '9' && c >= '0' ) || '.' == c )){
longDigit = atof(bufferDigit);
QueueInsert(q,longDigit);
i = 0;
}
}
if( '(' == c || '*' == c || '/' == c ){
Push(&s, c);
}
else if( '+' == c || '-' == c ){
if( !StackLength(s) )
Push(&s, c);
else{
Pop(&s, &e);
while( '(' != e ){
QueueInsert_operatorValue(q, e);
if( StackLength(s) == 0 ){
break;
}else
Pop(&s, &e);
}
if( '(' == e )
Push(&s, e);
Push(&s, c);
}
}else if( ')' == c ){
Pop(&s, &e);
while( '(' != e ){
QueueInsert_operatorValue(q, e);
Pop(&s, &e);
}
}else if( '#' == c){
break;
}else{
printf("input ERROR!\n");
return ERROR;
}
scanf("%c", &c);
}
while(StackLength(s)){
Pop(&s, &e);
QueueInsert_operatorValue(q, e);
}
QueueInsert_operatorValue(q,'#');
return OK;
}
Status ShowQueue(Queue q){
printf("The Reverse Polish Notation is:");
if(q.front == q.rear){
printf("Queue Empty");
return ERROR;
}
QueueNodePtr p = q.front->next;
while(p != q.rear){
if(p->flag)
printf("%g ", p->data);
else
printf("%c ", p->operator);
p = p->next;
}
printf("\n");
return OK;
}
/* The stack is used to solve the postfix expression ( Inverse polish expression ) The value of the.
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* | + . - . * . / . | Pop the top two elements of the stack to calculate, pushing the result to the top of the stack |
* | digital | Push it to the top of the stack |
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
* */
Status ValueExpression(Queue q){
Stack_2 s;
StackInit_2(&s);
double o1;
double o2;
QueueElemtype number;
QueueOperatorValue operator;
int symbol;
QueueDelete(&q,&number,&operator,&symbol);
while( symbol == 1 || ( symbol == 0 && '#' != operator)){
if(symbol == 1){
Push_2(&s, number);
}
else if(symbol == 0){
switch(operator){
case '+':
Pop_2(&s,&o1);
Pop_2(&s,&o2);
Push_2(&s,o2 + o1);
break;
case '-':
Pop_2(&s,&o1);
Pop_2(&s,&o2);
Push_2(&s,o2 - o1);
break;
case '*':
Pop_2(&s,&o1);
Pop_2(&s,&o2);
Push_2(&s,o2 * o1);
break;
case '/':
Pop_2(&s,&o1);
Pop_2(&s,&o2);
Push_2(&s,o2 / o1);
break;
}
}
QueueDelete(&q,&number,&operator,&symbol);
}
Pop_2(&s,&o1);
printf("The Value of the Expression is %g\n",o1);
return OK;
}
int main(){
Queue q;
QueueInit(&q);
Infix2Postfix(&q);
ShowQueue(q);
/*
QueueElemtype number;
QueueOperatorValue operator;
int symbol;
QueueDelete(&q,&number,&operator,&symbol);
printf("%f,%c,%d\n",number,operator,symbol);
*/
ValueExpression(q);
//Stack
/*
Stack s;
StackInit(&s);
StackElemtype c;
Push(&s,'1');
Push(&s,'2');
Push(&s,'3');
Push(&s,'4');
Pop(&s,&c);
printf("%c ", c);
Pop(&s,&c);
printf("%c ", c);
Pop(&s,&c);
printf("%c ", c);
Pop(&s,&c);
printf("%c ", c);
*/
//Queue
/*
Queue q;
QueueElemtype c;
QueueInit(&q);
QueueInsert(&q,1);
QueueInsert(&q,2);
QueueInsert(&q,3);
QueueInsert(&q,4);
QueueDelete(&q,&c);
printf("%d ", c);
QueueDelete(&q,&c);
printf("%d ", c);
QueueDelete(&q,&c);
printf("%d ", c);
QueueDelete(&q,&c);
printf("%d ", c);
if(QueueDelete(&q,&c)){
printf("%d ",c);
}
*/
/*
Queue q;
QueueInit(&q);
QueueInsert(&q,2.1);
QueueInsert_operatorValue(&q,'+');
QueueInsert(&q,43.1);
QueueInsert_operatorValue(&q,'a');
QueueInsert_operatorValue(&q,'(');
int iswho;
double d;
char c;
QueueDelete(&q,&d,&c,&iswho);
if(iswho == 1)
printf("%f ",d);
else
printf("%c ", c);
QueueDelete(&q,&d,&c,&iswho);
if(iswho == 1)
printf("%f ",d);
else
printf("%c ", c);
QueueDelete(&q,&d,&c,&iswho);
if(iswho == 1)
printf("%f ",d);
else
printf("%c ", c);
QueueDelete(&q,&d,&c,&iswho);
if(iswho == 1)
printf("%f ",d);
else
printf("%c ", c);
*/
return 0;
}
The above is the C language data structure stack and queue application, if you have any questions please leave a message or to the site community exchange discussion, thank you for reading, hope to help you, thank you for the support of the site!