/*
* Copyright (c) 2012 Fang Ying (Y. Fang), NEU Electric Engineering 20092725 ,fangying7@gmail.com
* Copyright (c) GPLv3
* All Rights Reserved.
* This program is free software;
*you can redistribute it and/or modify it under the terms of the GNU General Public License V3 as published by the
* Free Software Foundation, either version 2 or any later version.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details. A copy of the GNU General Public License is available at:
* http://www.fsf.org/licensing/licenses
*/
#ifndef _SQ_STACK_H_
#define _SQ_STACK_H_
#include <iostream>
using namespace std;
template <class T> //模板声明
class sq_stack
{
private:
int max; //存储空间容量
int top; //栈顶指针
T *s; //顺序栈的存储空间首地址
public:
sq_stack(int max); //构造函数，建立空栈
~sq_stack(); //析构函数
void print(); //顺序输出栈顶指针和栈中的元素
int flag(); //检测顺序栈的状态
void push(T); //压栈
T pop(); //弹栈
T read(); //读取栈顶数据
};
//建立容量为max的空栈
template <class T>
sq_stack<T>::sq_stack(int max)
{
this->max = max; //存储空间
s = new T[max]; //申请内存空间
top = 0;
return;
}
//顺序输出栈顶指针与栈中的元素
template <class T>
void sq_stack<T>::print()
{
int i;
cout<<"top = "<<top<<endl;
for (i = top ;i > 0 ;i--)
cout<<s[i-1]<<endl;
return;
}
//检测顺序栈的状态
template <class T>
int sq_stack<T>::flag()
{
if (top == max) return(-1); //存储空间已满，返回-1
if (top == 0) return(0); //
return (1);
}
//压栈
template <class T>
void sq_stack<T>::push(T x)
{
if (top == max)
{
cout<<"stack overflow!"<<endl;
return;
}
top++; //栈顶指针进1
s[top - 1] = x; //新元素入栈
return;
}
//弹栈
template <class T>
T sq_stack<T>::pop()
{
T y;
if (top == 0)
{
cout<<"underflow!"<<endl;
return -1;
}
y = s[top-1];
top -= 1;
return y;
}
//读取栈顶元素
template <class T>
T sq_stack<T>::read()
{
if (0 == top)
{cout<<"Stack empty!"<<endl; return -1;}
return s[top - 1]; //返回栈顶元素
}
//书序表空间回收
template <class T>
sq_stack<T>::~sq_stack()
{
delete s;
}
#endif
#include "sq_stack.h"
int main()
{
sq_stack<int> st(10);
st.push(50);
st.push(60);
st.push(46);
st.push(465);
st.push(712);
st.push(2747);
cout<<"输出战中的元素："<<endl;
st.print();
cout<<"栈顶元素:"<<st.read()<<endl;
cout<<"输出退栈元素:"<<endl;
cout<<st.pop()<<endl;
cout<<st.pop()<<endl;
cout<<st.pop()<<endl;
cout<<"再次输出栈顶指针和栈中的元素"<<endl;
st.print();
return 0;
}
#include "sq_stack.h"
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
using namespace std;
/*======================================================*/
/* 转换当前字符为实数 */
/*======================================================*/
double char2double(char *s, int *k)
{
double x,y = 1.0;
int fla g = 1;
char c;
x = 0.0;
c = s[*k]; //取得当前符号
while(c >= '0'&& c<'9' ||c=='.')
{
*k = *k + 1; //扫描指针加一
if (c >= '0'&& c<='9')
if(0 == flag) //转换小数后的值，并将整数部加上
{y = y*0.1; x=x+(c-48)*y;}
else
x=10*x+(c-48);
else
flag = 0;
c = s[*k];
}
return (x);
}
/* ====================================================*/
/* 判断运算符的优先级 */
/* ====================================================*/
int priority(char op)
{
int k = 0;
switch(op)
{
case '^':
k = 3;break;
case '*':
k = 2;break;
case '/':
k = 2;break;
case '+':
k = 1;break;
case '-':
k = 1;break;
case '(':
k = 0;break;
case ')':
k = 0;break;
case '\0':
k = -1;break;
default:
k = -2;break;
}
return (k);
}
int main()
{
sq_stack<double> sd(50); //操作数栈
sq_stack<char> sp(20); //操作符栈
char s[60],c; //s[60]存放输入的待处理字串
int flag =1 ,k;
double x, y; //左右操作数
sp.push('\0'); //表达式结束符进入运算符栈
cout<<"input formula:"<<endl;
cin>>s;
k = 0; //扫描指针初始化
c = s[k]; //取得当前字符
while(flag)
{
if ((c >= '0')&&( c<='9')||(c == '.')) //当前字符为数字字符或者小数点
sd.push(char2double(s ,&k)); //double atof(const char *ptr)将输入的字符串转换为浮点型数据
else if ((c == '(') || priority(c) > priority(sp.read()))
//当前符号位"("或者运算符的优先级大于运算符栈的栈顶运算符优先级
{
sp.push(c); //运算符入栈
k++; //扫描指针加一
}
else if ((c == '\0')&&(sp.read() == '\0'))
flag = 0;
else if ((c == ')')&&(sp.read() == '('))
//当前符号为")"，且运算符栈栈顶运算符为"("
{
sp.pop(); //从运算符栈顶退出左括号
k++; //扫描指针加一
}
else if (priority(c) <= priority(sp.read()))
//当前符号为")"，且运算符优先级不大于运算符栈栈顶的优先级
{
y = sd.pop(); //从操作数栈取右操作数
x = sd.pop(); //从操作数栈取左操作数
c = sp.pop(); //从运算符栈取运算符
switch(c)
{
case '^': x = pow(x,y);break;
case '*': x = x*y;break;
case '/': x = x/y;break;
case '+': x = x+y;break;
case '-': x = x-y;break;
}
sd.push(x); //将计算结果放回操作数栈
}
c = s[k]; //取得字符
}
cout<<s<<"="<<sd.read()<<endl; //输出计算结果
return 0;
}
