c语言-数据结构题目，四则运算

问题描述

数据结构题目，四则运算

用户从键盘输入一个计算表达式,用栈实现四则运算。表达式中含有数字,加减乘除,小括号。输出表达式的结果。用c语言实现

解决方案

四则运算 (数据结构)
数据结构：四则运算
一些数据结构题目的代码片段

解决方案二：

一年前我自己写的，稍微改改就能用
/***********************************
Coded by LC 2014/11/8 20:00

  • This is our last edition,and we *
    *changed some details from the book
    Later we studied some knowledge of
    STL template,and the effect is * *
    very good. * * * * * * * * * * * *
    *    *********************************/

#include"iostream"
#include"cstdlib"
#include"cmath"
#include"string"
#include"vector"

using namespace std;

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define LENTH " "

template

class stack
{
private:
T base;
T *top;
int stack_size;
public:
stack(void)
{
this->base = new T[STACK_INIT_SIZE];
if (!this->base)
puts("init_stack error_1"),exit(0);
this->top = this->base;
this->stack_size = STACK_INIT_SIZE;
}
~stack(void)
{}
T get_top(void)
{
if (this->top == this->base)
puts("get_top error"), exit(0);
return *(this->top - 1);
}
void push(T e)
{
if (this->top - this->base >= this->stack_size)
{
this->base = (T)realloc(this->base, (this->stack_size + STACKINCREMENT)*sizeof(T));
if(!this->base)
puts("push error"), exit(0);
this->top=this->base+this->stack_size;
this->stack_size+=STACKINCREMENT;
}
*(this->top++)=e;
}
T pop(void)
{
if(this->top==this->base)
puts("pop error"), exit(0);
return *(--(this->top));
}
};

void suffixion(string ,string &);
double calculate(string &);
char judge(char ,char );
bool is_binary_operator(char);
double calculate(string &);
double compute(double ,char ,double );
double compute(double ,char );

int main()
{
string infix;
string suffix=LENTH;
cout<<"Please input your infix expression(End with '='):"<
cin>>infix;
suffixion(infix,suffix);
cout<<"The suffix expression is:"<<suffix<<endl;
cout<<"The result is:"<<calculate(suffix)<<endl;
system("pause");
return 0;
}

void suffixion(string infix,string & suffix)
{
stack char_stack;
char_stack.push('=');
int j=0;
for(int i=0;infix[i]!='=';i++)
{
if(infix[i]>='0'&&infix[i]<='9')
{
suffix[j]=' ';
j++;
while(infix[i]>='0'&&infix[i]<='9'||infix[i]=='.')
{
suffix[j]=infix[i];
j++;
if(infix[i+1]>='0'&&infix[i+1]<='9'||infix[i+1]=='.')
i++;
else
break;
}
suffix[j]=' ';
j++;
}
else if(infix[i]=='(')
{
char_stack.push('(');
}
else if(infix[i]==')')
{
while(char_stack.get_top()!='(')
{
suffix[j]=char_stack.pop();
j++;
}
char_stack.pop();
}
else if(infix[i]>='a'&&infix[i]<='z')
{
int flag;
switch(infix[i])
{
case 'c':case's':
{
//char_stack.push(infix[i]);
flag=2;
}break;
case 'l':
{
if(infix[i+1]=='n')
{
// char_stack.push('n');
i+=1;
flag=0;
}
else if(infix[i+1]=='o')
{
// char_stack.push('l');
flag=2;
}
}break;
default: break;
}
switch(judge(char_stack.get_top(),infix[i]))
{
case '>':
{
while(judge(char_stack.get_top(),infix[i])=='>')
{
suffix[j]=char_stack.pop();
j++;
}
char_stack.push(infix[i]);
}
break;

            case '=':
            {
                char_stack.pop();
            }
            break;

            case '<':
            {
                char_stack.push(infix[i]);
            }
            break;

            default: break;
        }
        i+=flag;
    }
    else if(is_binary_operator(infix[i]))
    {
        switch(judge(char_stack.get_top(),infix[i]))
        {
            case '>':
            {
                while(judge(char_stack.get_top(),infix[i])=='>')
                {
                    suffix[j]=char_stack.pop();
                    j++;
                }
                char_stack.push(infix[i]);
            }
            break;

            case '=':
            {
                char_stack.pop();
            }
            break;

            case '<':
            {
                //cout<<endl<<"push_isok=1"<<endl;
                char_stack.push(infix[i]);
            }
            break;

            default: break;
        }
    }
}

while(char_stack.get_top()!='=')//last , infix[i]=''
{
    suffix[j]=char_stack.pop();
    j++;
}
char_stack.pop();
suffix[j]='';

}

double calculate(string & suffix)
{
int i=0;
double a,b,n,k=0.1;
int dot_flag=0,push_flag=0;
stack num_stack;
for(int i=0;suffix[i]!='';i++)
{
n=0;
push_flag=0;
dot_flag=0;
k=0.1;
while((suffix[i]>='0'&&suffix[i]<='9')||suffix[i]=='.')
{
push_flag=1;
if(suffix[i]=='.')
dot_flag=1;
else
{
if(dot_flag==0)
n=n*10+(suffix[i]-'0');
else
{
n=n+(suffix[i]-'0')*k;
k/=10;
}
}
if((suffix[i+1]>='0'&&suffix[i+1]<='9')||suffix[i++]=='.')
i++;
}
if(push_flag==1)
num_stack.push(n);
if(is_binary_operator(suffix[i]))
{
b=num_stack.pop();
a=num_stack.pop();
// cout<
num_stack.push(compute(a,suffix[i],b));
}
else if(suffix[i]>='a'&&suffix[i]<='z')
{
a=num_stack.pop();
// cout<<endl<<"computing："<<suffix[i]<<a<<endl;
num_stack.push(compute(a,suffix[i]));
}
}
return num_stack.get_top();
}

char judge(char a,char b)
{
int m,n;
if(a=='(' && b==')') return '=';
else
{
switch(a)
{
case '(':case '=':m=0;break;
case '+':case '-':m=1;break;
case '*':case '/':m=2;break;
case '^':case 'c':case 's':case 'l':case 'n':m=3;break;
default : break;
}
switch(b)
{
case '=':case ')':n=0;break;
case '+':case '-':n=1;break;
case '*':case '/':n=2;break;
case '^':case 'c':case 's':case 'l':case 'n':n=3;break;
case '(':n=4;break;
default : break;
}
if(m
return '
else
return '>';
}
}

bool is_binary_operator(char e)
{
return (e=='+'||e=='-'||e=='*'||e=='/'||e=='^');
}

double compute(double a,char operate,double b)
{
switch(operate)
{
case '+':return a+b;
case '-':return a-b;
case '*':return a*b;
case '/':return a/b;
case '^':return pow(a,b);
default : break;
}
}

double compute(double a,char operate)
{
switch(operate)
{
case 'c':return cos(a);
case 's':return sin(a);
case 'l':return log10(a);
case 'n':return log(a);
default : break;
}
}

解决方案三：

#include
#include
#include
#include
#define STACK_INIT_SIZE 100
typedef char SElemType;
typedef struct
{
SElemType * base;
SElemType * top;
int stacksize;
}SqStack;
typedef struct
{
double * base;
double * top;
int stacksize;
}QSqStack;
int InitStack(SqStack &S)
{
S.base=(SElemType )malloc(STACK_INIT_SIZE * sizeof(SElemType));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return 1;
}
int QInitStack(QSqStack &Q)
{
Q.base=(double *)malloc(STACK_INIT_SIZE * sizeof(double));
Q.top=Q.base;
Q.stacksize=STACK_INIT_SIZE;
return 1;
}
char icp(char e)
{
if(e=='#') return 0;
if(e=='(') return 6;
if(e==')') return 1;
if(e=='+'||e=='-') return 2;
if(e==''||e=='/') return 4;
}
char isp(char e)
{
if(e=='#') return 0;
if(e=='(') return 1;
if(e==')') return 6;
if(e=='+'||e=='-') return 3;
if(e=='*'||e=='/') return 5;
}
void jisuan(QSqStack &Q,char e)
//将栈丁的两个值计算，并把所得到的值放回栈中
{
double i;
switch(e){
case '+':i=*--Q.top;*(Q.top-1)+=i;break;
case '-':i=*--Q.top;*(Q.top-1)-=i;break;
case '*':i=*--Q.top;*(Q.top-1)*=i;break;
case '/':i=*--Q.top;*(Q.top-1)/=i;break;}
}
void Push1(SqStack &S,char e)
{
S.top++=e;
}
char istake(char e)
{
if(e=='+'||e=='/'||e==''||e=='-'||e=='('||e==')')
return 0;
else
return 1;
}
void Push2(SqStack &S,QSqStack &Q,char a)
//将中缀表达式转换为后缀表达式，并依次将字符和数值放入两个栈中
{
int i=0,len,x=1,k,y;
double e,j,z;
len=strlen(a);
for(;i
{
int flag=1;
if(istake(a[i]))//判断传入值是变量 数值还是字符
{
if(a[i]>='a'&&a[i]<='z')
{
printf("请输入变量值：");
scanf("%lf",&e);
*Q.top++=e;
i++;
}
else{
e=a[i]-'0';
while(a[++i]>='0'&&a[i]<='9')
{
e=e*10+(a[i]-'0');
}
if(a[i]=='.')
{
while(a[++i]>='0'&&a[i]<='9')
{
x=x*10;
j=(double)(a[i]-'0')/x;
e=e+j;
}
}
if(a[i]=='^')
{
z=e;
i++;
y=a[i]-'0';
while(a[++i]>='0'&&a[i]<='9')
{
y=y*10+(a[i]-'0');
}
for(k=1;k
e=e*z;
}
*Q.top++=e;
x=1;
}
}
else
{
if(icp(a[i])>isp((S.top-1)))
{
* S.top++=a[i];
i++;
}
else
{
jisuan(Q,*(S.top-1));
S.top=S.top-1;
while(flag)
{
if(icp(a[i])
{
jisuan(Q,*(S.top-1));
S.top=S.top-1;
flag=1;
}
else if(icp(a[i])==isp(*(S.top-1)))
{
S.top=S.top-1;
flag=0;
}
else {
if(a[i]!=')')
*S.top++=a[i];
flag=0;
}
}
i++;
}
}
}
}
int main()
{
char a[100];
SqStack S;//建立栈存放字符
QSqStack Q;//建立栈存放数值
InitStack(S);
QInitStack(Q);
scanf("%s",a);
Push1(S,'#');
Push2(S,Q,a);//字符串依次进栈
for(;S.top-1>S.base;)
{
jisuan(Q,*(S.top-1));
S.top=S.top-1;
}
printf("%lf",*(Q.top-1));
return 0;
}
已测可用

时间： 2024-09-25 12:36:25

c语言-数据结构题目，四则运算的相关文章

数据结构 c语言-C语言数据结构课程设计实现一个集合数据结构

问题描述 C语言数据结构课程设计实现一个集合数据结构 题目:设计并实现一个集合数据结构Set.一个集合中没有重复元素,支持下列运算: boolean add(E o) 如果 set 中尚未存在指定的元素o,则添加此元素. boolean addAll(Set c) 如果 set 中没有指定集合c中的所有元素,则将其添加到此 set 中. void clear() 移除 set 中的所有元素. boolean contains(E o) 如果 set 包含指定的元素o,则返回 true. bool

树-数据结构题目，求解，没有想出来

问题描述 数据结构题目,求解,没有想出来 2-3树是一种特殊的树,它满足两个条件:(多选题) (1)每个内部结点有两个或三个子结点:(2)所有的叶结点到根的路径长度相同: 如果一棵2-3树有10个叶结点,那么它可能有_________个非叶结点. A.5 B.8 C.6 D.7 解决方案 所有的叶结点到根的路径长度相同: 也就是最下层是叶子节点. 因此这个题目转化为有10个叶子节点,2个一组,或者3个一组分组,得到上一层,再2个一组或者3个一组往上推,直到最后只有一组. 1 2 3 4 5 6

一道c语言的题目，求解答

问题描述 一道c语言的题目,求解答 有函数原型为void f(int,int *);主函数中有变量定义:int a,*p=&a,b[10];则下列几种调用错误的是: A·f(a,p) B·f(*p,b) C·f(b,&a) D·f(*p,p) 我的想法是:子函数要接收一个整形变量,一个指针变量,那么B选项中b不是指针常量么? 求助大神们解答!谢谢! 答案是C 解决方案 C B中 b 是数组名,可以看作 const 的指针 C中第一个参数是b,但实际参数是 int 解决方案二: B 选项中的

c语言数据结构问题 代码相似性度量

问题描述 c语言数据结构问题 代码相似性度量 我的思路:对要进行比较的所有代码段进行词法分析,并转化为特定的标记(token)串,自己制定一个转换规则.接着,通过两两比较标记(token)串来确定代码之间的相似性,并由此确定代码之间抄袭的程度. 将这两个代码分别转换为token串后,基于算法RKR-GST( running-karp-rabin greedy-string-tiling)算法思想,循环求取两个标记串中未被匹配部分的最大公共子串,将其用空格代替,并根据公式求出两个token串A,B

c语言-C语言,数据结构,树的孩子兄弟表示法,程序一切正常,但是有个问题不太懂了

问题描述 C语言,数据结构,树的孩子兄弟表示法,程序一切正常,但是有个问题不太懂了 我的困惑就是在creatTree函数中,参数是(LTNode &T),也就是说是struct node**型指针,但是在递归中,也就是在creatTree(T->firstchild)中,T->firstchild应该是struct node*型指针,为什么依然可以运行,且运行正确? printfTree()函数也是一样,我就不再多写了 而在main()函数中,我也只创建了LTNode T;在调用的时候

c语言数据结构，求算法

问题描述 c语言数据结构,求算法 把一个单链表LA中的奇数项和偶数项分开,分别放在两个单链表LB,LC中(要求利用原空间,头结点空间可另外开辟) 解决方案 (C语言-数据结构与算法)还原二叉树数据结构和算法系列 - c语言归并排序法 解决方案二: 对LA进行遍历,依次把LA中的项加入LB,LC中.依靠修改原LA中项的指针实现. 解决方案三: //输入时以-1结束#include <stdio.h>#include <stdlib.h>struct node{ int data; s

c语言-华为C语言面试题目，输出内容的值

问题描述 华为C语言面试题目,输出内容的值 11.写出下列代码的输出内容 #include int inc(int a) { return(++a); } int multi(int*a,int*b,int*c) { return(*c=*a**b); } typedef int(FUNC1)(int in); typedef int(FUNC2) (int*,int*,int*); void show(FUNC2 fun,int arg1, int*arg2) { INCp=&inc; int

vc++-C语言的题目，急求！！！

问题描述 C语言的题目,急求!!! 已知有100个产品销售记录,每个产品销售记录由产品代码dm(字符型4位),产品名称mc(字符型10位),单价dj(整型),金额je(长整型)五部分组成.其中:金额=单价*数量计算得出.(要求把100个销售记录存入结构数组sell中.按产品名称从小到大进行排列,若产品名称相等,则按金额从小到大进行排列,最终排列结果仍存入结构数组sell中,最后输出结构数组sell) 解决方案 http://wenku.baidu.com/link?url=VwK62eHFUyC

调用函数-一道C语言的题目，求大神解答

问题描述 一道C语言的题目,求大神解答 输入一个正整数,逐位分割该数的每一位数字,求由数字所构成的最大整数.例如:输入624891,得到最大整数:986421.要求定义和调用函数计算并返回一个x可构成的最大整数. 解决方案 #include #define N 20 int fun(int n) { int x,t,s[N]={0},i,j,len; for(len=0;x!=0;len++) { x=n/10; s[len]=n%10; n=x; } for(i=0;i<len-1;i++)