精华内容
下载资源
问答
  • C语言栈实现四则运算

    千次阅读 多人点赞 2019-06-27 16:41:24
    说明:本代码旨在帮助实现遇到困难的低年级学生或非计算机相关专业学生借鉴,是借鉴,不是抄袭,我强烈建议你自己先...补充:如果正是大一的你,你想实现功能更强大的计算器,比如用QT实现不仅仅四则运算的,可以...

    说明:本代码旨在帮助实现遇到困难的低年级学生或非计算机相关专业学生借鉴,是借鉴,不是抄袭,我强烈建议你自己先实现一遍。这是我一个非计算机专业的同学和我一起完成的。这是我通过栈实现的,代码质量简洁性效率性还是很好的,逻辑清晰(相对初学者,我认为),bug基本改完了,至少我找到的都改了。如有更好的方式欢迎指出。

    补充:如果正是大一的你,你想实现功能更强大的计算器,比如用QT实现不仅仅四则运算的,可以在大二参考我另外的一篇博客。

    当然等你学数值分析之后,如果想把里面的算法怎么解决方程实现一次,也可以参考我的另外的博客。

    // bds_qz.cpp: 定义控制台应用程序的入口点。
    //
    #include "stdafx.h"
    #include <stdio.h>
    #include <stdlib.h>
    #define n 50
    #pragma warning(disable:4996)
    typedef struct
    {
    	char a[n];
    	int size;//表示栈中含有的元素数量
    } stack;
    char pop(stack *p)
    {
    	if (p->size == 0)
    		printf("空栈");
    	else
    	{
    		--(p->size);
    		return p->a[p->size];
    	}
    }
    char top(stack *p)
    {
    	if (p->size == 0)
    		return '/0';//抛出/0字符代表空
    	else
    	{
    		return p->a[p->size - 1];
    	}
    }
    int empty(stack *p)
    {
    	return p->size == 0;
    }
    void push(stack *p, char b)
    {
    	p->a[p->size] = b;
    	++p->size;
    }
    int compare(char a)//用于比较优先级
    {
    	int i;
    	switch (a)
    	{
    	case '+':
    		i = 1;
    		break;
    	case '-':
    		i = 1;
    		break;
    	case '*':
    		i = 2;
    		break;
    	case '/':
    		i = 2;
    		break;
    	default:
    		i = 0;
    		break;
    	}
    	return i;
    }
    void merge(float *a, float b, char c)//用于将两数字合并,注意前面的数字传地址
    {
    	if (c == '-')
    	{
    		(*a) -= b;
    	}
    	else if (c == '+')
    	{
    		(*a) += b;
    	}
    	else if (c == '*')
    	{
    		(*a) *= b;
    	}
    	else
    		(*a) /= b;
    }
    void qiuzhi(char *bds)
    {
    	int i = 0;
    	stack *ysf = (stack*)malloc(sizeof(stack));//为表达式开辟一个stack
    	ysf->size = 0;
    	float num[50];//用于求值的数组
    	int numpos = 0;//用于求值的数组位置//ps因为num这个栈用的操作非常的少,而stack没有泛化,所以没有采用栈
    	printf("后缀表达式为:");
    	while (bds[i] != '=')
    	{
    		if (bds[i] == '\0')
    		{
    			printf("表达式应该有=");
    			return;
    		}
    		if (bds[i] <= '9'&&bds[i] >= '0')//为数字的情况,转换为1个数,如234
    		{
    			num[++numpos] = 0;
    			while (bds[i] <= '9'&&bds[i] >= '0')
    			{
    				num[numpos] *= 10;
    				num[numpos] += (bds[i] - '0');
    				++i;
    			}
    			if (bds[i] == '.')
    			{
    				double f_car = 0.1;//定义基数
    				++i;
    				while (bds[i] <= '9'&&bds[i] >= '0')
    				{
    					num[numpos] += ((bds[i] - '0')*f_car);
    					f_car *= 0.1;
    					++i;
    				}
    			}//计算小数点
    		}
    		else
    		{
    			if (empty(ysf))
    				push(ysf, bds[i]);
    			else
    			{
    				if (bds[i] == '(')
    					push(ysf, bds[i]);
    				else if (bds[i] == ')')
    				{
    					while (top(ysf) != '(')
    					{
    						merge(&num[numpos - 1], num[numpos], top(ysf));
    						printf("%c", pop(ysf));
    						--numpos;
    					}
    					pop(ysf);//弹出右括号
    				}
    				else
    				{
    					while (compare(bds[i])<=compare(top(ysf)))
    					{
    						merge(&num[numpos - 1], num[numpos], top(ysf));
    						printf("%c", pop(ysf));
    						--numpos;
    					}
    					push(ysf, bds[i]);
    				}
    			}
    			++i;
    		}
    	}
    	while (!empty(ysf))
    	{
    		merge(&num[numpos - 1], num[numpos], top(ysf));
    		printf("%c", pop(ysf));
    		--numpos;
    	}
    	printf("\n运算结果为:%.2f\n", num[1]);
    }
    int main()
    {
    	stack *p;
    	char bds[50];
    	scanf("%s", bds);
    	qiuzhi(bds);
    	return 0;
    }
    
    

    示例:

    展开全文
  • 内容为整数和小数的四则运算,用C语言实现的,使用了结构。可以实现+-*/和()运算,现在分享给大家!
  • C语言程序:用栈实现四则运算

    千次阅读 多人点赞 2019-02-19 21:58:48
    栈实现四则运算 第一部分 :LinkStack.h #ifndef LINKSTACK_H #define LINKSTACK_H #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #define SUCCESS 10000 #define FAILURE 10001 #define ...

    用栈实现四则运算

    第一部分 :LinkStack.h

    #ifndef LINKSTACK_H
    #define	LINKSTACK_H
    
    #include <stdlib.h>
    #include <stdio.h>
    #define SUCCESS 10000
    #define FAILURE 10001
    #define	TRUE	10002
    #define FALSE	10003
    
    typedef struct StackNode
    {
    	int data;
    	struct StackNode *next;
    }Node;
    
    typedef struct StackInfo
    {
    	struct StackNode *top;
    	int length;
    }Stack;
    
    int InitStack(Stack **s);
    int Push(Stack*s, int e);
    int EmptyStack(Stack *s);
    int GetTop(Stack *s);
    int Pop(Stack *s);
    int ClearStack(Stack *s);
    int DestroyStack(Stack **s);
    #endif
    
    
    

    第二部分 :LinkStack.c

    #include "LinkStack.h"
    
    int InitStack(Stack **s)
    {
    	if (NULL == s)
    	{
    		return FAILURE;
    	}
    	*s = (Stack *)malloc(sizeof(Stack));
    	if (NULL == *s)
    	{
    		return FAILURE;
    	}
    	(*s)->top = NULL;
    	(*s)->length = 0;
    	return SUCCESS;
    }
    
    
    int Push(Stack *s, int e)
    {
    	if (NULL == s)
    	{
    		return FAILURE;
    	}
    
    	Node *tmp = (Node *)malloc(sizeof(Node));
    	if (NULL == tmp)
    	{
    		return FAILURE;
    	}
    
    	tmp->data = e;
    	tmp->next = s->top;
    	s->top = tmp;
    	s->length++;
    
    	return SUCCESS;
    }
    
    int EmptyStack(Stack *s)
    {
    	if (NULL == s)
    	{
    		return FAILURE;
    	}
    	return s->top == NULL ? TRUE : FALSE;
    }
    
    int GetTop(Stack *s)
    {
    	if (NULL == s)
    	{
    		return FAILURE;
    	}
    	if (NULL == s->top)
    	{
    		return FAILURE;
    	}
    	return s->top->data;
    }
    
    int Pop(Stack *s)
    {
    	if (NULL == s)
    	{
    		return FAILURE;
    	}
    	if (s->top == NULL)
    	{
    		return FAILURE;
    	}
    
    	int tmp;
    	Node *stmp = s->top;
    	tmp = s->top->data;
    	s->top = stmp->next;
    	free(stmp);
    	stmp = NULL;
    	s->length--;
    
    	return tmp;
    
    }
    
    int ClearStack(Stack *s)
    {
    	if (NULL == s)
    	{
    		return FAILURE;
    	}
    	Node *tmp;
    	while (s->top != NULL)
    	{
    		tmp = s->top->next;
    		free(s->top);
    		s->top = tmp;
    	}
    	s->length = 0;
    	return SUCCESS;
    }
    
    int DestroyStack(Stack **s)
    {
    	if (NULL == s)
    	{
    		return FAILURE;
    	}
    
    	free(*s);
    	*s = NULL;
    	return SUCCESS;
    }
    
    

    第三部分 :Calculator.c

    #include "LinkStack.h"
    
    int Priority(char ch)	//判断操作符优先级
    {
    	switch (ch)
    	{
    		case '(':
    			return 3;
    		case '*':
    		case '/':
    			return 2;
    		case '+':
    		case '-':
    			return 1;
    		default :
    			return 0;
    	}
    }
    
    int main()
    {
    	Stack *s_num, *s_opt;
    	char opt[128]  ={0};
    	int i = 0, tmp = 0;
    	int num1, num2;
    	if ((InitStack(&s_num) == FAILURE) || (InitStack(&s_opt) == FAILURE))
    	{
    		printf("Init Failure !\n");
    	}
    	printf("输入四则表达式:");
    	scanf("%s", opt);
    
    	while (opt[i] != '\0' || EmptyStack(s_opt) != TRUE)	//表达式没结束 或 操作符不为空
    	{
    		if (opt[i] >= '0' && opt[i] <= '9')	//判断表达式是否为数字,数字直接进栈
    		{
    			tmp = tmp * 10 + opt[i] - '0';	//后一个为数字时 前一个乘以10 加上后一个
    			i++;
    			if (opt[i] >'9' || opt[i] < '0')	//判断后一个是否为操作符
    			{
    				Push(s_num, tmp);	//操作数进栈
    				tmp = 0;	//清零,用以记录下一个操作数
    			}
    		}
    		else	//表达式为操作符
    		{
    			//	1、操作符出栈不计算
    			if (GetTop(s_opt) == '(' && opt[i] ==')')	//直接出栈,不计算,栈顶为'(' ,表达式为')'
    			{
    				Pop(s_opt);	//括号直接出栈
    				i++;
    				continue;	//继续下一次循环
    			}
    			//	2、操作符进栈
    			if ((EmptyStack(s_opt) == TRUE) 	//操作符栈为空
    				|| (Priority(opt[i]) > Priority(GetTop(s_opt))) 	//表达式操作符优先级 > 栈顶操作符优先级
    				|| (GetTop(s_opt) == '(' && opt[i] != ')')) 	//栈顶为'('  && 表达式当前值不为 ')'
    			{
    				Push(s_opt,opt[i]);	//操作符进栈
    				i++;
    				continue;	//继续下一次循环
    			}
    			//	2、操作符出栈计算	
    			if (Priority(opt[i]) <= Priority(GetTop(s_opt)) 	//表达式操作符优先级 <= 栈顶操作符优先级
    				|| (opt[i] == '0' && EmptyStack(s_opt) != TRUE) 	//表达式为空 && 操作符栈不为空
    				|| opt[i] == ')')	//表达式为')'
    			{
    				num1 = Pop(s_num);	//数字栈顶出栈
    				num2 = Pop(s_num);	//数字栈第二个数字出栈
    				switch (Pop(s_opt))	//后出的数字在前
    				{
    					case '+':
    						Push(s_num, num2 + num1);
    						break;
    					case '-':
    						Push(s_num, num2 - num1);
    						break;
    					case '*':
    						Push(s_num, num2 * num1);
    						break;
    					case '/':
    						Push(s_num, num2 / num1);
    						break;
    				}	A  
    				// i++;			//在操作符进栈时已经自加
    				// continue;
    			}
    		}
    	}
    
    	printf("Result = %d\n", GetTop(s_num));
    	return 0;
    }
    

    至此已经实现四则混合运算

    展开全文
  • 运算带小数带负号 求大神指导 主要我就是负号不会解决[img=https://img-bbs.csdn.net/upload/202104/21/1618967900_228928.jpg][/img]
  • 可以实现小数的四则运算,对我之前上传的那个四则运算的改进,现在与大家分享
  • C语言:用栈实现四则运算

    万次阅读 多人点赞 2017-11-25 19:49:59
    = ')') || Priority(str[i]) > Priority(GetTop(&opt)))//进栈不参与运算 { Push(&opt,str[i]); i++; continue; } if(GetTop(&opt) == '(' && str[i] == ')')//出栈不参与运算 { Pop(&...
    要注意对情况的分类。
    #include <stdio.h>
    #include <stdlib.h>
    
    #define OK     10000001
    #define ERROR  10000002
    
    struct node
    {
    	int data;
    	struct node *next;
    };
    typedef struct node Node;
    
    struct stack
    {
    	Node *top;
    	int count;
    };
    typedef struct stack Stack;
    
    int InitStack(Stack *l)
    {
    	l->top = NULL;
    	l->count = 0;
    
    	return OK;
    }
    
    int EmptyStack(Stack *s)
    {
    	return (s->count == 0) ? OK : ERROR;
    }
    
    int Push(Stack *s, int e)
    {
    	Node *p = (Node *)malloc(sizeof(Node));
    	if(p == NULL)
    	{
    		return ERROR;
    	}
    	p->data = e;
    	p->next = s->top;
    	s->top = p;
    	s->count++;
    
    	return OK;
    }
    
    int GetTop(Stack *s)
    {
    	if(NULL == s->top)
    	{
    		return ERROR;
    	}
    
    	return (s->top->data);
    }
    
    int Priority(char s)
    {
    	switch(s)
    	{
    		case '(':
    			return 3;
    		case '*':
    		case '/':
    			return 2;
    		case '+':
    		case '-':
    			return 1;
    		default:
    			return 0;
    	}
    }
    
    int Pop(Stack *s)
    {
    	int e;
    
    	if(NULL == s->top)
    	{
    		return ERROR;
    	}
    
    	Node *p = s->top;
    	e = p->data;
    	s->top = p->next;
    	free(p);
    	s->count--;
    
    	return e;
    }
    
    int main()
    {
    	Stack num, opt;
    	char str[100]={0};
    	int i = 0, tmp = 0, j;
    
    	if(InitStack(&num) != OK || InitStack(&opt) != OK)
    	{
    		printf("Init Failure!\n");
    		exit(1);
    	}
    
    	printf("Please Input Operator :\n");
    	scanf("%s",str);
    
    	while(str[i] != '\0' || EmptyStack(&opt) != OK)
    	{
    		if(str[i] >= '0' && str[i] <= '9')
    		{
    			tmp = tmp * 10 + str[i] - '0';
    			i++;
    			if(str[i] < '0' || str[i] > '9')
    			{
    				Push(&num,tmp);
    				tmp = 0;
    			}
    		}
    		else
    		{
    			if((EmptyStack(&opt) == OK) || (GetTop(&opt) == '(' && str[i] != ')') || Priority(str[i]) > Priority(GetTop(&opt)))//进栈不参与运算
    			{
    				Push(&opt,str[i]);
    				i++;
    				continue;
    			}
    			if(GetTop(&opt) == '(' && str[i] == ')')//出栈不参与运算
    			{
    				Pop(&opt);
    				i++;
    				continue;
    			}
    			if((str[i] == '\0' && EmptyStack(&opt) != OK) || (str[i] == ')' && GetTop(&opt) != '(') || Priority(str[i]) <= Priority(GetTop(&opt)))//出栈并参与运算
    			{
    				switch(Pop(&opt))
    				{
    					case '+':
    						Push(&num, Pop(&num) + Pop(&num));
    						break;
    					case '-':
    						j = Pop(&num);
    						Push(&num, Pop(&num) - j);
    						break;
    					case '*':
    						Push(&num, Pop(&num) * Pop(&num));
    						break;
    					case '/':
    						j = Pop(&num);
    						Push(&num, Pop(&num) / j);
    				}
    				continue;
    			}
    		}
    	}
    
    	printf("%d",Pop(&num));
            printf("\n");
    
            return 0;
    }

    展开全文
  • = '(') // 优先级不低于c且栈顶不等于'(',出栈 { expression[num].type = 2; expression[num].element.char_element = topElement; num++; pop(pSymboolStack); } else break; } while (!isEmpty(pSymboolStack));...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    gets(szExpression);

    // 中缀表达式转后缀表达式,结果保存在expression中

    for (int i = 0; i < strlen(szExpression); i++)

    {

    if (isspace(szExpression[i])) // 空白字符

    {

    if (bFindBegin)

    {

    expression[num].type = 1;

    expression[num].element.int_element = atoi(pbegin);

    num++;

    bFindBegin = false;

    }

    continue;

    }

    if (isdigit(szExpression[i])) // 数字字符

    {

    if (!bFindBegin)

    {

    pbegin = &szExpression[i];

    bFindBegin = true;

    }

    continue;

    }

    c = szExpression[i];

    if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')') // 操作符字符

    {

    if (bFindBegin)

    {

    expression[num].type = 1;

    expression[num].element.int_element = atoi(pbegin);

    num++;

    bFindBegin = false;

    }

    if (c != ')')

    {

    if (!isEmpty(pSymboolStack)) // 存在操作符

    {

    if (c == '(') // 直接入栈

    push(pSymboolStack, c);

    else {

    do

    {

    char topElement = top(pSymboolStack);

    if (compare(topElement, c) >= 0 && topElement != '(') // 优先级不低于c且栈顶不等于'(',则出栈

    {

    expression[num].type = 2;

    expression[num].element.char_element = topElement;

    num++;

    pop(pSymboolStack);

    }

    else

    break;

    } while (!isEmpty(pSymboolStack));

    // c入栈

    push(pSymboolStack, c);

    }

    } // 不存在操作符,直接入栈

    else

    push(pSymboolStack, c);

    }

    else // c == ')'

    {

    while( (c =top(pSymboolStack)) != '(')

    {

    expression[num].type = 2;

    expression[num].element.char_element = c;

    num++;

    展开全文
  • C语言实现四则运算

    千次阅读 2019-04-02 15:56:33
    C语言实现四则运算C语言实现四则运算(QG第二次训练营作业) 头文件 代码: #include <stdio.h> #include<malloc.h> #include<math.h> typedef enum Status { ERROR = 0, SUCCESS = 1 } ...
  • 栈实现四则运算(c语言)

    千次阅读 2013-07-10 18:19:10
    有一句计算机界中的至理名言:   程序=数据结构+算法 ...用这个数据结构实现四则运算   算法思想是借鉴了>(清华大学出版社 严蔚敏)中的一些思想 , 最原始的算法就是波兰一位逻辑学家的逆波兰表示法
  • 数据结构中的四则运算实现...............................................
  • c语言数据结构四则运算(带括号)的实现,里面有解释
  • 利用栈实现四则运算

    千次阅读 2018-04-17 20:37:13
    #include&lt;iostream&gt;#include&lt;stack&gt;#include&lt;cstring&gt;using namespace std;int caculate(int a,int b,char sign);void destack_two(stack&...int lev...
  • C语言实现整数四则运算表达式的计算

    万次阅读 多人点赞 2016-03-29 02:24:28
    从标准输入中读入一个整数算术运算表达式,如5 - 1 * 2 * 3 + 12 / 2 / 2 = 。计算表达式结果,并输出。 要求: 1、表达式运算符只有+、-、*、/,表达式末尾的’=’字符表示表达式输入结束,表达式中可能会出现空格...
  • C语言使用栈实现数学表达式的四则运算(含括号)

    千次阅读 多人点赞 2019-08-02 14:16:57
    我这里是使用两个栈实现的,直接对中缀表达式进行运算的 输入的算式以#结尾 除此之外该问题还可以使用一个栈,如:先转化成后缀表达式;或者使用char型共享栈,操作数进出栈时进行类型转换即可。 Evaluation.h #...
  • double op(double a,char Op,double b)//运算函数 { if(Op=='+') return a+b; if(Op=='-') return a-b; if(Op=='*') return a*b; if(Op=='/')//题目是非负整数 { if(b==0) { printf("error\n"); ...
  • 1、可以计算多位整数或者小数范围内的...2、C语言,通过入栈方式实现四则运算优先级顺序。。 3、用了两个栈实现,操作数栈和运算符栈,这一点不是很让人满意。。 4、具体实现方式可参考严蔚敏《数据结构》相应内容。。
  • #include #define MAX 20//定义两个,分别存放运算数和运算符struct SNode_Num{int datas[MAX];int top;};typedef struct SNode_Num OperateNum;struct SNode_Symbol{char symbol[MAX];int top;};typedef struct ...
  • 四则运算 C语言

    2009-02-21 17:43:34
    利用栈实现四则运算, 有侵权之嫌。但事实上, 它有了改进。 因为可以支持多位的整数的运算,例如55+444*(233-231)。 不太好的地方就是用了两个栈, 但实现还是一样的哦!! 呵呵,
  • 实现四则运算的计算器

    千次阅读 2016-12-16 21:16:26
    这几天一直在做停车场和计算器项目,在停车场做完后,再去做计算器,突然发现简单了很多,对大体的一个思路有了很清楚的了解,与停车场相比,计算器只用了一个结构变量,只有一个操作数和一个运算符,而停车场用...
  • 判断四则运算字符串的括号是否匹配,可以用以个来计算,开始是空,从头遍历所有字符,找到'(',压栈,找到')'弹出一个元素,遍历完成以后如果是空表示正常,非空,或则中间出现问题都表示括号不正常。2.分解...
  • //清空ope和num OpePush('\0'); if (*s=='+') s++; else if (*s=='-') { s++; OpePush('-'); NumPush('0'); NumPush(','); } do { if (*s>='0' && *s|| *s=='。 ') { do NumPush(*s++); while (*s>='0' && *s||...
  • 没想到不能免费下载,不过可以去我的博客那里拷贝我的代码来直接用
  • #include<stdio.h> #include<string.h> #include<windows.h> #include<malloc.h> #define TRUE 1 #define FALSE 0 #define Elemtype int #define elemtype char ...’,’>

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,070
精华内容 6,428
关键字:

c语言栈实现四则运算

c语言 订阅