cal算法

最新推荐文章于 2023-07-11 16:06:06 发布

碧月有约

最新推荐文章于 2023-07-11 16:06:06 发布

阅读量1.1k

点赞数

分类专栏： Linux

Linux 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

1.算法1

#include <stdio.h>
#include <stdlib.h>

struct s_node
{
int data;
struct s_node *next;
};
typedef struct s_node s_list;
typedef s_list *link;
link operator=NULL;
link operand=NULL;

link push(link stack,int value)
{
link newnode;

newnode=(link) malloc(sizeof(s_list));
if(!newnode)
{
printf("\nMemory allocation failure!!!");
return NULL;
}
newnode->data=value;
newnode->next=stack;
stack=newnode;
return stack;
}

link pop(link stack,int *value)
{
link top;
if(stack !=NULL)
{
top=stack;
stack=stack->next;
*value=top->data;
free(top);
return stack;
}
else
*value=-1;
}

int empty(link stack)
{
if(stack==NULL)
return 1;
else
return 0;

}

int is_operator(char operator)
{
switch (operator)
{
case '+': case '-': case '*': case '/': return 1;
default:return 0;
}
}

int priority(char operator)
{
switch(operator)
{
case '+': case '-' : return 1;
case '*': case '/' : return 2;
default: return 0;
}
}

int two_result(int operator,int operand1,int operand2)
{
switch(operator)
{
case '+':return(operand2+operand1);
case '-':return(operand2-operand1);
case '*':return(operand2*operand1);
case '/':return(operand2/operand1);
}
}

int main(void)
{
char expression[50];
int position=0;
int op=0;
int operand1=0;
int operand2=0;
int evaluate=0;

printf("\nPlease input the inorder expression:");
gets(expression);

while(expression[position]!='\0'&&expression[position]!='\n')
{
if(is_operator(expression[position]))
{
if(!empty(operator))
while(priority(expression[position])<= priority(operator->data)&&
!empty(operator))
{
operand=pop(operand,&operand1);
operand=pop(operand,&operand2);
operator=pop(operator,&op);
operand=push(operand,two_result(op,operand1,operand2));
}
operator=push(operator,expression[position]);
}
else
operand=push(operand,expression[position]-48);
position++;
}
while(!empty(operator))
{
operator=pop(operator,&op);
operand=pop(operand,&operand1);
operand=pop(operand,&operand2);

operand=push(operand,two_result(op,operand1,operand2));
}
operand=pop(operand,&evaluate);
printf("The expression [%s] result is '%d' ",expression,evaluate);
getchar();

return EXIT_SUCCESS;
}

2.算法二:

//============================================================================
// Name        : testCplus.cpp
// Author      : Ben
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

//int main() {
//	cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
//	return 0;
//}

//有这么简单的课程设计吗?没别的要求?就只要行数么?那就简单了,自己可以设计一个有加减乘除功能的计算器就ok了,设计简单,而且够100多行了,楼主自己写吧//***************************************************************************
 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> // malloc()等
 #include<limits.h> // INT_MAX等
 #include<stdio.h> // EOF(=^Z或F6),NULL
 #include<stdlib.h> // atoi()
// #include<io.h> // eof()
 #include<math.h> // floor(),ceil(),abs()
// #include<process.h> // exit()
// #include<iostream.h> // cout,cin
 // 函数结果状态代码
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 // #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
 typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
 typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

//***************************************************************************
//栈的储存结构

typedef struct{
 //运算符栈
 char *base;
 char *top;
 int stacksize;
}SqStack1;

typedef struct{
 //运算数栈
 float *base;
 float *top;
 int stacksize;
}SqStack2;

//***************************************************************************
//以下是运算符栈的基本操作函数

Status InitStack(SqStack1 &S){
 //初始化一个栈
 S.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));
 if(!S.base)exit(OVERFLOW);
 S.top=S.base;
 S.stacksize=STACK_INIT_SIZE;
 return OK;
}//InitStack

Status DestroyStack(SqStack1 &S){
 //销毁栈S
 free(S.top);
 free(S.base);
 return OK;
}//DestroyStack

char GetTop(SqStack1 S){
 //若栈不空，则返回S的栈顶元素，并返回OK；否则返回ERROR
 if(S.top==S.base)return ERROR;
 return *(S.top-1);
}//Gettop

Status Push(SqStack1 &S,char e){
 //插入元素e为新的栈顶元素
 if(S.top-S.base>=S.stacksize){
  //栈满，追加储存空间
  S.base=(char *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));
  if(!S.base)exit(OVERFLOW);
  S.top=S.base+S.stacksize;
  S.stacksize+=STACKINCREMENT;
 }
 *S.top++=e;
 return OK;
}//Push

Status Pop(SqStack1 &S,char &e){
 //若栈不空，则删除S的栈顶元素，用e返回其值；并返回OK；否则返回ERROR
 if(S.top==S.base)return ERROR;
 e=*(--S.top);
 return OK;
}//Pop

//***************************************************************************
//以下是运算数栈的基本操作函数

Status InitStack(SqStack2 &S){
 //初始化一个栈
 S.base=(float *)malloc(STACK_INIT_SIZE*sizeof(float));
 if(!S.base)exit(OVERFLOW);
 S.top=S.base;
 S.stacksize=STACK_INIT_SIZE;
 return OK;
}//InitStack

Status DestroyStack(SqStack2 &S){
 //销毁栈S
 free(S.top);
 free(S.base);
 return OK;
}//DestroyStack

float GetTop(SqStack2 S){
 //若栈不空，则返回S的栈顶元素，并返回OK；否则返回ERROR
 if(S.top==S.base)return ERROR;
 return *(S.top-1);
}//Gettop

Status Push(SqStack2 &S,float e){
 //插入元素e为新的栈顶元素
 if(S.top-S.base>=S.stacksize){
  //栈满，追加储存空间
  S.base=(float *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(float));
  if(!S.base)exit(OVERFLOW);
  S.top=S.base+S.stacksize;
  S.stacksize+=STACKINCREMENT;
 }
 *S.top++=e;
 return OK;
}//Push

Status Pop(SqStack2 &S,float &e){
 //若栈不空，则删除S的栈顶元素，用e返回其值；并返回OK；否则返回ERROR
 if(S.top==S.base)return ERROR;
 e=*(--S.top);
 return OK;
}//Pop

//***************************************************************************
//以下是相关的运算符判断函数

char Precede(char A,char B){
 //比较运算符A, B的优先关系，A，B的范围仅限于'+','-','*','/','^','(',')','='
 //返回'>','<','='
 switch(A){
  case '+':switch(B){
     case '+':return '>';
     case '-':return '>';
     case '*':return '<';
     case '/':return '<';
     case '^':return '<';
     case '(':return '<';
     case ')':return '>';
     case '=':return '>';
     default:printf("表达式错误！\n");exit(0);
     }
  case '-':switch(B){
     case '+':return '>';
     case '-':return '>';
     case '*':return '<';
     case '/':return '<';
     case '^':return '<';
     case '(':return '<';
     case ')':return '>';
     case '=':return '>';
     default:printf("表达式错误！\n");exit(0);
     }
  case '*':switch(B){
     case '+':return '>';
     case '-':return '>';
     case '*':return '>';
     case '/':return '>';
     case '^':return '<';
     case '(':return '<';
     case ')':return '>';
     case '=':return '>';
     default:printf("表达式错误！\n");exit(0);
     }
  case '/':switch(B){
     case '+':return '>';
     case '-':return '>';
     case '*':return '>';
     case '/':return '>';
     case '^':return '<';
     case '(':return '<';
     case ')':return '>';
     case '=':return '>';
     default:printf("表达式错误！\n");exit(0);
     }
  case '^':switch(B){
     case '+':return '>';
     case '-':return '>';
     case '*':return '>';
     case '/':return '>';
     case '^':return '>';
     case '(':return '<';
     case ')':return '>';
     case '=':return '>';
     default:printf("表达式错误！\n");exit(0);
     }
  case '(':switch(B){
     case '+':return '<';
     case '-':return '<';
     case '*':return '<';
     case '/':return '<';
     case '^':return '<';
     case '(':return '<';
     case ')':return '=';
     case '=':printf("表达式错误！\n");exit(0);
     default:printf("表达式错误！\n");exit(0);
     }
  case ')':switch(B){
     case '+':return '>';
     case '-':return '>';
     case '*':return '>';
     case '/':return '>';
     case '^':return '>';
     case '(':printf("表达式错误！\n");exit(0);
     case ')':return '>';
     case '=':return '>';
     default:printf("表达式错误！\n");exit(0);
     }
  case '=':switch(B){
     case '+':return '<';
     case '-':return '<';
     case '*':return '<';
     case '/':return '<';
     case '^':return '<';
     case '(':return '<';
     case ')':printf("表达式错误！\n");exit(0);
     case '=':return '=';
     default:printf("表达式错误！\n");exit(0);
     }
  default:printf("表达式错误！\n");exit(0);
 }
}//Precede

Status InOP(char c){
 //判断c是否是运算符，是则返回TRUE,否则返回FALSE
 switch(c){
  case '+':return TRUE;
  case '-':return TRUE;
  case '*':return TRUE;
  case '/':return TRUE;
  case '^':return TRUE;
  case '(':return TRUE;
  case ')':return TRUE;
  case '=':return TRUE;
  default:return FALSE;
 }
}//InOP


//***************************************************************************

float Operate(float a,char theta,float b){
 switch(theta){
  case '+':return a+b;
  case '-':return a-b;
  case '*':return a*b;
  case '/':
   if(b==0){
    printf("分母不能为0!\n");
    exit(0);
   }
   else return a/b;
  case '^':
   if(a==0&&b<=0){
    printf("0的指数必须大于0!\n");
    exit(0);
   }
   else return (float)pow(a,b);
  default:printf("表达式错误！\n");exit(0);
 }
}//Operate

Status EvaluateExpression(){
 //算术表达式求值
 char c,x,theta,prec;
 //c是每次读取的字符，x是存放脱括号后的多余的括号，theta是运算符，prec是c的前一个字符
 float a,b,result;//a、b是每次从运算数栈中取出的要进行运算的数，result存放最终结果
 float cc,flag,ii,minus=1;
 //cc存放由字符串转化而来的浮点数，flag用于标记是否已读取过小数点，
 //ii存放小数部分需要缩小的倍数,minus用于记录该数前是否有负号
 SqStack1 OPTR;
 SqStack2 OPND;
 InitStack(OPTR);InitStack(OPND);
 Push(OPTR,'=');
 prec='=';scanf("%c",&c);
 while(c!='='||GetTop(OPTR)!='='){
  cc=0;flag=0;ii=10;
  if(c=='-'&&(prec=='='||prec=='(')){minus=-1;prec=c;scanf("%c",&c);}
  //若某“-”前面是“=”(第一个符号就是“-”)或“(”，则此为负号，不是减号
  else if(!InOP(c)){
   while(!InOP(c)){
    if(c>=48&&c<=57){
     if(flag==0)cc=cc*10+c-48;//小数点之前
     else if(flag==1){cc=cc+(c-48)/ii;ii*=10;}//小数点之后
     else {printf("小数点错误！\n");exit(0);}//小数点有错
    }
    else if(c=='.')flag++;//读到小数点
    else {printf("表达式错误！\n");exit(0);}
    prec=c;scanf("%c",&c);
   }
   cc*=minus;minus=1;
   Push(OPND,cc);
  }//不是运算符则进OPND栈
  else
   switch(Precede(GetTop(OPTR),c)){
    case '<':Push(OPTR,c);prec=c;scanf("%c",&c);break;//栈顶元素优先级低
    case '=':Pop(OPTR,x);prec=c;scanf("%c",&c);break;//脱括号并接收下一字符
    case '>'://退栈并将运算结果入栈
     Pop(OPTR,theta);
     Pop(OPND,b);Pop(OPND,a);
     Push(OPND,Operate(a,theta,b));
     break;
   }
 }
 result=GetTop(OPND);
 printf("%f\n",result);
 //DestroyStack(OPTR);
 //DestroyStack(OPND);
 return OK;
}//EvaluateExpression

int main(void){
 printf("                   **********************\n");
 printf("                   *   欢迎使用计算器!  *\n");
 printf("                   **********************\n");
 printf("请输入表达式，以“=”结束：\n");
 printf("(支持实数间的加(+)、减(-)、乘(*)、除(/)、乘方(^)、单目减(-)运算)\n");
 EvaluateExpression();
 exit (0);
 return EXIT_SUCCESS;
}