2019-9-17 c++实现栈 及 中缀转后缀+计算后缀实现简单计算器

//头文件 stack.h
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int ElementType;
#ifndef __STACK__
#define __STACK__
class Stack
{
public:
    Stack(ElementType sz);//直接构造一个有maxsize的空栈
    Stack(const Stack& S);

    void FreeStack();
    int Push(ElementType item);
    ElementType Pop();
    ElementType GetTop();
    void MakeEmpty();
    int IsEmpty();
    int IsFull();

    int top;
    int MaxSize;
    ElementType * elements;
};
#endif

// stack.cpp文件
#include "stack.h"
Stack::Stack(ElementType sz)
{
    top = -1 ;
    MaxSize = sz;
    elements = new ElementType[MaxSize];
}
Stack::Stack(const Stack& S)
{
    top = S.top;
    MaxSize = S.MaxSize;
    elements = new ElementType[MaxSize];
    memcpy(elements,S.elements,sizeof(S.elements));
}

void Stack::FreeStack()
{
    free(this->elements);
}

int Stack::Push(ElementType item)
{
    if ( ! this->IsFull() )
    {
        this->elements[++(this->top)] = item;
        return 0;
    }
    else return -1;
}

ElementType Stack::Pop()
{
    if ( ! this->IsEmpty())
        return this->elements[(this->top)--];
    else
    {
        printf("stack is empty and the process will be killed.\n");
        exit(1);
    }
}

ElementType Stack::GetTop()
{
    if ( ! this->IsEmpty() )
        return this->elements[this->top];
    else
    {
        printf("stack is empty and the process will be killed.\n");
        exit(1);
    }
}

void Stack::MakeEmpty()
{
    this->top = -1;
}

int Stack::IsEmpty()
{
    return (this->top == -1) ;
}

int Stack::IsFull()
{

    return (this->top == this->MaxSize-1);
}

//计算后缀表达式的值
#include "stack.h"
#define maxsize 80
void EvaluatePostfix(char *buf)
{
    Stack my_stack(maxsize);
    int i=0, k;
    while(buf[i] != '\0')
    {
        switch(buf[i])
        {
            case '+':
                k = my_stack.Pop() + my_stack.Pop();
                my_stack.Push(k);
                break;
            case '-':
                k = my_stack.Pop();
                k = my_stack.Pop() - k;
                my_stack.Push(k);
                break;
            case '*':
                k = my_stack.Pop() * my_stack.Pop();
                my_stack.Push(k);
                break;
            case '/':
                k = my_stack.Pop();
                k = my_stack.Pop()/k;
                my_stack.Push(k);
                break;
            default:
                my_stack.Push((int)(buf[i]-48));
        }
        i++;
    }
    printf("The value is %d\n",my_stack.Pop());
}

#中缀转后缀
#include "stack.h"
#include <iostream>
using namespace std;
#define maxsize 80

char* InfixToPostfix(char * InfixBuf)
{
    int i=0, tail=0;
    char * PostfixBuf = new char[strlen(InfixBuf)+1];
    Stack my_stack(maxsize);

    while ( InfixBuf[i] != '\0')
    {
        if ( InfixBuf[i] >= '0' && InfixBuf[i] <= '9') PostfixBuf[tail++] = InfixBuf[i];
        else if ( InfixBuf[i] == ')')
        {
            while( my_stack.GetTop() != '(' )
            {
                PostfixBuf[tail++] = my_stack.GetTop();
                my_stack.Pop();
            }
            my_stack.Pop();
        }
        else
        {
            if ( my_stack.IsEmpty() ) my_stack.Push(InfixBuf[i]);
            else{
                switch( my_stack.GetTop() )
                {
                    case '(':
                        my_stack.Push(InfixBuf[i]);
                        break;
                    case '*':
                        if ( InfixBuf[i] == '(' ) my_stack.Push(InfixBuf[i]);
                        else
                        {
                            PostfixBuf[tail++] = '*';
                            my_stack.Pop();
                            my_stack.Push(InfixBuf[i]);
                        }
                        break;
                    case '/':
                        if ( InfixBuf[i] == '(' ) my_stack.Push(InfixBuf[i]);
                        else
                        {
                            PostfixBuf[tail++] = '/';
                            my_stack.Pop();
                            my_stack.Push(InfixBuf[i]);
                        }
                        break;
                    case '+':
                        if ( InfixBuf[i] == '(' || InfixBuf[i] == '*' || InfixBuf[i] == '/')
                            my_stack.Push(InfixBuf[i]);
                        else
                        {
                            PostfixBuf[tail++] = '+';
                            my_stack.Pop();
                            my_stack.Push(InfixBuf[i]);
                        }
                        break;
                    case '-':
                        if ( InfixBuf[i] == '(')
                            my_stack.Push(InfixBuf[i]);
                        else if ( InfixBuf[i] == '*')
                            my_stack.Push(InfixBuf[i]);
                        else if ( InfixBuf[i] == '/')
                            my_stack.Push(InfixBuf[i]);
                        else
                        {
                            PostfixBuf[tail++] = '-';
                            my_stack.Pop();
                            my_stack.Push(InfixBuf[i]);
                        }
                        break;
                }
            }
        }
        i++;
    }
    while(! my_stack.IsEmpty() )
    {
        PostfixBuf[tail++] = my_stack.GetTop();
        my_stack.Pop();
    }
    return PostfixBuf;
}

//主函数
#include "stack.h"
#include "EvaluatePostfix.h"
#include "InfixToPostfix.h"

void Caculate()
{
    char InfixBuf[maxsize] ;
    char * PostfixBuf ;
    printf("Input Infix:");
    while(scanf("%s",InfixBuf) != EOF)
    {
        PostfixBuf = InfixToPostfix(InfixBuf);
        printf("the Postfix:%s\n",PostfixBuf);
        EvaluatePostfix(PostfixBuf);
        printf("\nInput Infix:");
    }
}
int main()
{
    //printf(InfixToPostfix("1+2"));
    Caculate();
    return 0;
}