数据结构与算法学习笔记——堆栈及其应用（10以内简单四则计算器）

/***********************************************************************
* Copyright(C):
* Filename: main.c
* Author:
* Version:
* Date:
* Description:
* Modified:
************************************************************************/
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "stack.h"

// Macros definition

#define ADD(a,b)   ((a)+(b))
#define SUB(a,b)   ((a)-(b))
#define DIV(a,b)   ((a)/(b))
#define MUL(a,b)   ((a)*(b))

// Variables definition

char _buff[255];								
char _operator[] = {'+','-','*','/','(',')'};

// Functions declaration

int Calculate(char *src, int len);
int GetInput(char *, int max);
int IsIllegal(const char *src, int len);
int opera(char c, int a, int b);
int PrefixToPostfix(char *a, int len);


//-------------------------------------------
//
// main
//
//
int 
main(int argc, char** argv){

    int len;
	while( 1  ){

	    if ( (len=GetInput(_buff, sizeof(_buff))) == 0 ){
			continue;
		}
		
		// 如果输入'quit'则退出程序
		if ( strcmp(_buff, "quit") == 0 ){
			break;
		}		

		// 判断是否含有非法字符
		if ( IsIllegal(_buff, len) ){
			printf("there are illlegal characters!\n");
			continue;
		}	

		// 将前缀表达式转换为后缀表达式
		len = PrefixToPostfix(_buff, len); 
	
		// 计算并输出结果
		printf("%d \n", Calculate(_buff,len) );
	}
	
    return 0;    
}


//--------------------------------------
//
// IsIllegal
//
// 
int 
IsIllegal(const char *src, int len){

	int i,j;

	if ( src[len-1] == '\n'){
		len = len-1;
	}
	
	for ( i=0; i<len; i++ ){
		if ( src[i] < '0' || src[i] > '9' ){
			j = 0;
			for ( j=0; j<sizeof(_operator); j++ ){
				if ( src[i] == _operator[j] ){
					break;
				}
			}
			if ( j == sizeof(_operator) ){
				return(1);
			}
		}
	}
	
	return 0;
}



//-----------------------------------------
//
// Calculate()
//
//
int 
Calculate(char *src, int len){

	int a,b,i;	
	Stack s;
	InitStack(&s,len+5);

	for (i=0; i<len; i++){
		if ( src[i]>='0' && src[i]<='9' ){
			PushStack(&s,(int)src[i]-'0');
		}
		else{
			a = PopStack(&s);
			b = PopStack(&s);
			PushStack(&s,opera(src[i],a,b));			
		}
	}
	return PopStack(&s);
}



//---------------------------------------
//
// opera() 
//
//
int 
opera(char c, int a, int b){
	if ( c == '+' )	return ADD(a,b);
	if ( c == '-' ) return SUB(b,a);
	if ( c == '*' ) return MUL(a,b);
	if ( c == '/' ) return DIV(b,a);
	
	return 0;
}



//-----------------------------------------
//
// GetInput()
//
//
int 
GetInput(char *a, int max){
    
	int len;

    if ( NULL != fgets(a, max, stdin) ){
		if ( (len = strlen(a)) == 0 ){
			return 0;
		}		

		if ( a[len-1] == '\n' ){
			a[ len-1 ] = '\0';
			return(--len);
		}
	}
	
	return 0;
}



//---------------------------------------------
//
// PrefixToPostfix
//
int 
PrefixToPostfix(char *a, int len){

    int i,j;
    char *tmparray = (char*)malloc(sizeof(char)*len+1);
    Stack s;

    InitStack(&s,len+5);

    for ( i=j=0; i<len; i++ ){
        switch( a[i] )
        {
            case ')':  while( ((char)TopStack(&s) != '(') && (!IsEmpty(&s)) ){
                            tmparray[j++] = (char)PopStack(&s);    
                        }
                        PopStack(&s);
                break; 
            case '(':   PushStack(&s,(int)a[i]);
                break;
            case '-':
            case '+':   if ( !IsEmpty(&s) ){
                            while( ((char)TopStack(&s)=='*') 
                                || ((char)TopStack(&s)=='/')
                                || ((char)TopStack(&s)=='+')
                                || ((char)TopStack(&s)=='-')
                                ){
                                tmparray[j++] = (char)PopStack(&s);
                            }
                        }
                        PushStack(&s,(int)a[i]);
                break;
            case '*':   
            case '/':   if( !IsEmpty(&s) ){
                            while( (char)TopStack(&s)=='*' 
                                || (char)TopStack(&s)=='/'
                                ){
                                tmparray[j++] = PopStack(&s);
                            }
                        }
                        PushStack(&s,(int)a[i]);
                break;
            default:
                tmparray[j++] = a[i];
            break;   
        }
    }
    while( !IsEmpty(&s) ){
        tmparray[j++] = (char)PopStack(&s);
    }

    for ( i=0; i<j; i++ ){
        a[i] = tmparray[i];
    }

    free(tmparray);

	return j;
}

/*******************************************************************
* Copyright(C):
* Filename:stack.c
* Author:
* Version:
* Date:
* Description:
*******************************************************************/

#include <malloc.h>

#include "stack.h"



//---------------------------------------------------
//
// DisposeStack()
//
//
void
DisposeStack(Stack *S){

	S->capacity = 0;
	S->top_stack = -1;
	free(S->array);
	S->array = NULL;
}


//---------------------------------------------------
//
// InitStack()
//
//
int 
InitStack(Stack *S, int size){

    if ( size <= 0 ) return -1;

    if ( (S->array = (int*)malloc(sizeof(int)*size)) == NULL ){
        return -1;
    }     

    S->capacity = size;
    S->top_stack = -1;

    return 0;
}


//---------------------------------------------------
// 
// IsEmpty()
//
//
int 
IsEmpty(Stack *S){
    return( S->top_stack == -1 );
}


//---------------------------------------------------
//
// IsFull()
//
//
int 
IsFull(Stack *S){
    return( S->top_stack == S->capacity-1 );
}


//---------------------------------------------------
//
// MakeEmptyStack()
//
//
void 
MakeEmptyStack(Stack *S){
	S->top_stack = -1;
}


//---------------------------------------------------
//
// PushStack()
//
//
int 
PushStack(Stack *S, int e){
    if ( !IsFull(S) ){
        S->array[ ++S->top_stack ] = e; 
      
      return 0;
    }

    return -1;
}


//---------------------------------------------------
//
// PopStack()
//
//
int 
PopStack(Stack *S){
    if ( !IsEmpty(S) ){
        return( S->array[ S->top_stack-- ] );
    }

    return -1;
}


//---------------------------------------------------
//
// TopStack()
//
//
int 
TopStack(Stack *S){
    return( S->array[ S->top_stack ] );
}

stack.h 文件

#ifndef STACK_H
#define STACK_H


typedef struct tagStack
{
    int *array;
    int top_stack;
    int capacity;  
}Stack;

//-----------function declaration---------------

int InitStack(Stack *S, int size);
int IsEmpty(Stack *S);
int IsFull(Stack *S);
void MakeEmptyStack(Stack *S);
int PopStack(Stack *S);
int PushStack(Stack *S, int e);
int TopStack(Stack *S);



#endif // STACK_H