简单计算器的实现

最新推荐文章于 2023-09-04 08:53:26 发布
最新推荐文章于 2023-09-04 08:53:26 发布
阅读量120 收藏
点赞数 1
分类专栏： c 程序 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54167891/article/details/119414924
版权

简单计算器的实现

思路

  1. 以字符串形式读入每一个数
  2. 将每个字符转化为对应的数字，并以单链表存储
  3. 根据选择进行相应的操作

代码实现

#include"shenming.h"
#include"shixiang.h"
int main(){
	int n;
	while(1){
		map();
		printf("请输入你的选择：");
		scanf("%d",&n);
		switch(n){
			case 1 :
				_add();
				break;
			case 2 :
				_sub();
				break;
			case 3 :
				_mul();
				break;
			case 4 :
				_div();
				break;
			case 5 :
				exit(-1);
			default:
				printf("输入错误，退出！！！");
				exit(0);
		}
	}
}

自定义头文件

shenming.h
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h> 
int length1=0,length2=0;
typedef struct node{
	int data;
	struct node *next;		//声明链表 
}node;
void print(node *p);
void dele(node *s);
void map();

//chenfa
node *add2(node *first1,node *first2);
node *add1(node *nums[]);
node *divid(node *first,int a,int i);
node *mul(node *first1,node *first2);
node *change(char a[]);
void _mul();

//chufa
node *div(node *first1,int b);
node * change1(char a[]);
void _div();

//jiafa
node *add(node *first1,node *first2);
void _add();

//jianfa
int compete(node *first1,node *first2);
node *sub(node *first1,node *first2);
void _sub();
shixiang.h

//打印链表 
void print(node *p){
	while(p->next!=NULL){
		p=p->next;
		printf("%d",p->data);
	}
	printf("\n");
}
//清除 
void dele(node *s){
	node *p;
	while(s!=NULL){
		p=s;
		s=s->next;
		free(p);
	}
}

void map(){
	printf(
	"——————————————————————————1.加法——————————————————————————\n"
	"——————————————————————————2.减法——————————————————————————\n"
	"——————————————————————————3.乘法——————————————————————————\n"
	"——————————————————————————4.除法——————————————————————————\n"
	"——————————————————————————5.退出——————————————————————————\n"
	);
}

node *change(char a[]){
	node *head=(node *)malloc(sizeof(node));
	head->next=NULL;
	for(int i=0;i<strlen(a);i++){
		int temp=a[i]-'0';
		node *p=(node *)malloc(sizeof(node));		//头插法，逆序 
		p->data=temp;
		p->next=head->next;
		head->next=p;
	}
	return head;
}

//相乘部分 
node *add2(node *first1,node *first2){
	int a=0,c=0,d=0,f=0;
	node *result=(node *)malloc(sizeof(node));
	node *s=result,*end;
	result->next=NULL;
	while(first1->next!=NULL&&first2->next!=NULL){
		first1=first1->next;first2=first2->next;
		a=first1->data;c=first2->data;
		d=a+c;
		if(f!=0){
			d+=f;
			f=0;
		}
		f=d/10;
		d=d%10;
		node *p=(node *)malloc(sizeof(node));
		p->data=d;
		s->next=p;//尾插法 
		s=p;
	}

		while(first1->next!=NULL){
			first1=first1->next;
			node *p=(node *)malloc(sizeof(node));
			
			if(f!=0){
				first1->data+=f; 
				f=0;
			}
			if(first1->data>=10){
				f=first1->data/10;
				first1->data=first1->data%10;
				
			}
			p->data=first1->data;
			s->next=p;//尾插法 
			s=p;
		}
		while(first2->next!=NULL){
			first2=first2->next;
			node *p=(node *)malloc(sizeof(node));
			if(f!=0){
				first2->data+=f;
				f=0;
			}
			if(first2->data>=10){
				f=first2->data/10;
				first2->data=first2->data%10;
			}
			p->data=first2->data;
			s->next=p;//尾插法 
			s=p;
		}
	s->next=NULL;
	return result;
}

node *add1(node *nums[]){
	node *sta[100];
	int top=-1;
	for(int i=0;i<length2;i++){
		top+=1;
		sta[top]=nums[i];
	}
	while(top){
		node *p1,*p2;
		p1=sta[top--];
		p2=sta[top--];
		sta[++top]=add2(p1,p2);
	}
	return sta[top];
}

node *divid(node *first,int a,int i){
	int y=0,x,t;
	node *head=(node *)malloc(sizeof(node));
	node *s=head;
	while(i){
		node *p=(node *)malloc(sizeof(node));//填充0 
		p->data=0;
		s->next=p;
		s=p;
		i--;
	}
	while(first->next!=NULL){
		first=first->next;
		x=first->data;
		t=x*a;
		if(y!=0){
			t+=y;
			y=0;
		}
		y=t/10;
		t=t%10;
		node *p=(node *)malloc(sizeof(node));
		p->data=t;
		s->next=p;
		s=p;
	}
	if(y!=0){
		node *p=(node *)malloc(sizeof(node));
		p->data=y;
		s->next=p;
		s=p;
	}
	s->next=NULL;
	return head;
}
node *mul(node *first1,node *first2){
	int c=0;
	node *nums[length2];
	node *result1=(node *)malloc(sizeof(node)),*result=(node *)malloc(sizeof(node));
	result->next=NULL;
	for(int i=0;i<length2;i++){
		first2=first2->next;
		int x=first2->data;
		nums[i]=divid(first1,x,i);
	}
	result1=add1(nums);
	while(result1->next!=NULL){
		result1=result1->next;
		node *p=(node *)malloc(sizeof(node));
		p->data=result1->data;
		p->next=result->next;
		result->next=p;
	}
	return result;
}

void _mul(){
	int a;
	char c;
	char str1[100],str2[100];
	node *first1,*first2;
	
	printf("请输入被乘数:");
	scanf("%s",str1);
	first1=change(str1);
	
	printf("请输入乘数:");
	scanf("%s",str2);
	first2=change(str2);
	
	length1=strlen(str1);
	length2=strlen(str2);
	node *result=mul(first1,first2);
	printf("结果是：");
	
	print(result);
	dele(first1);
	dele(first2);
	dele(result);
}

//相除部分 
node *div(node *first1,int b){
	node *result=(node *)malloc(sizeof(node)),*s=result;
	node *w=result;
	int t,sum=0,x,i;
	if(length1<=length2){
		
		for(i=length1-1;i>=0;i--){
			first1=first1->next;
			t=first1->data*pow(10,i);
			sum+=t;
		}
		node *p=(node *)malloc(sizeof(node));
		p->data=sum/b;
		s->next=p;
		s=p;
	}
	else{
		while(first1->next!=NULL){
			first1=first1->next;
			sum*=10;
			sum+=first1->data;
			x=sum/b;
			sum%=b;
			node *p=(node *)malloc(sizeof(node));
		    p->data=x;
			s->next=p;
			s=p;
		}
		int m=length1-1;
		while(m--){
			node *z=w->next;
			if(z->data==0){
			w->next=z->next;
			free(z);
			}
			else
				break;
		}
	}
	s->next=NULL;
	return result;
}

node * change1(char a[]){
	node *head=(node *)malloc(sizeof(node));
	node *s=head;
	for(int i=0;i<strlen(a);i++){
		int temp=a[i]-'0';
		node *p=(node *)malloc(sizeof(node));		
		p->data=temp;
		s->next=p;//尾插法 
		s=p;
	}
	s->next=NULL;
	return head;
}

void _div(){
	int a;char c,str1[100];
	int b,t;
	node *first1;

	printf("请输入被除数:");
	scanf("%s",str1);
	first1=change1(str1);
	length1=strlen(str1);
	
	printf("请输入除数:");
	scanf("%d",&b);
	t=b;
	while(t!=0){
		t/=10;
		length2++;
	}
	node *result=div(first1,b);
	printf("结果是：");
	print(result);
	dele(first1);
	dele(result);
}

//相加部分
node *add(node *first1,node *first2){
	int a=0,c=0,d=0,f=0;
	node *result=(node *)malloc(sizeof(node));
	node *s=result,*end;
	result->next=NULL;
	while(first1->next!=NULL&&first2->next!=NULL){
		first1=first1->next;first2=first2->next;
		a=first1->data;c=first2->data;
		d=(a+c)%10;
		if(f!=0){
			d+=f;	
			f=0;
		}
		f=(a+c)/10;
		node *p=(node *)malloc(sizeof(node));
		p->data=d;
		p->next=s->next;
		s->next=p;
	}
		while(first1->next!=NULL){
			first1=first1->next;
			node *p=(node *)malloc(sizeof(node));
			if(f!=0){
				first1->data+=f;
				f=0;
			}
			p->data=first1->data;
			p->next=s->next;
			s->next=p;
		}
		while(first2->next!=NULL){
			first2=first2->next;
			node *p=(node *)malloc(sizeof(node));
			
			if(f!=0){
				first1->data+=f;	
				f=0;
			}
			
			p->data=first2->data;
			p->next=s->next;//头插法 
			s->next=p;
		}
	return result;
}

void _add(){
	int a;char c;
	char str1[100],str2[100];
	node *first1,*first2;
	
	
	printf("请输入第一个数：");
	scanf("%s",str1);
	first1=change(str1);
	
	printf("请输入第二个数：");
	scanf("%s",str2);
	first2=change(str2);
	
	node *result=add(first1,first2);
	printf("结果是：");
	print(result);
	dele(first1);
	dele(first2);
	dele(result);
}

//减法部分
//比较 
int compete(node *first1,node *first2){
	node *s1=(node *)malloc(sizeof(node));
	node *s2=(node *)malloc(sizeof(node));
	
	s1->next=NULL;s2->next=NULL;
	
	while(first1->next!=NULL){
		first1=first1->next;first2=first2->next;
		
		node *p=(node *)malloc(sizeof(node));
		p->data=first1->data;
		p->next=s1->next;
		s1->next=p;
		
		node *q=(node *)malloc(sizeof(node));
		q->data=first2->data;
		q->next=s2->next;
		s2->next=q;
	}
	while(s1->next!=NULL){
		s1=s1->next;s2=s2->next;
		if((s1->data)>(s2->data)){
			return 1;
		}
	}
	return 0;
}

//相减 
node *sub(node *first1,node *first2){
	int a=0,c=0,d=0,f=0,b;
	node *result=(node *)malloc(sizeof(node));
	node *q=result;
	result->next=NULL;
	node *s=result;
	if(length1>length2){
		while(first2->next!=NULL){
		first1=first1->next;first2=first2->next;
		a=first1->data;
		b=first2->data;
		if(a<b){
			a+=10;
			first1->next->data-=1;		//相减 
		}
		d=a-b;
		node *p=(node *)malloc(sizeof(node));
		p->data=d;
		p->next=s->next;
		s->next=p;
		}
		while(first1->next!=NULL){
			first1=first1->next;
			node *p=(node *)malloc(sizeof(node));//处理残余数 
			p->data=first1->data;
			p->next=s->next;
			s->next=p;
		}
		while(length1--){
			node *z=q->next;
			if(z->data==0){		//清除前导 0 
			q->next=z->next;
			free(z);
			}
		}	
	}
	else if(length1==length2){
		int flag=compete(first1,first2);
		if(flag){
			while(first1->next!=NULL){
				first1=first1->next;first2=first2->next;
				a=first1->data;
				b=first2->data;
				if(a<b){
					a+=10;
					first1->next->data-=1;		//相减 
				}
				d=a-b;
				node *p=(node *)malloc(sizeof(node));
				p->data=d;
				p->next=s->next;
				s->next=p;
			}
		while((q->next->data==0)&&length1){
			node *z=q->next;
			if(z->data==0){
			q->next=z->next;		//清除前导 0  
			free(z);
			}
			length1--;
		}	
		}
		
		
	else{
	while(first1->next!=NULL){
				first1=first1->next;first2=first2->next;
				a=first2->data;
				b=first1->data;
				if(a<b){
					a+=10;
					first2->next->data-=1;		//相减 
				}
				d=a-b;
				node *p=(node *)malloc(sizeof(node));
				p->data=d;
				p->next=s->next;
				s->next=p;
			}
		while((q->next->data==0)&&length1){
			node *z=q->next;
			if(z->data==0){
			q->next=z->next;			//清除前导 0  
			free(z);
			}
			length1--;
		}
		if(result->next->data!=0) result->next->data=-result->next->data;	//判断，是否将头部置为负		
	}	
	}
	
	
	else{
		while(first1->next!=NULL){
		first1=first1->next;first2=first2->next;
		a=first2->data;
		b=first1->data;
		if(a<b){
			a+=10;
			first2->next->data-=1;	//相减 
		}
		d=a-b;
		node *p=(node *)malloc(sizeof(node));
		p->data=d;
		p->next=s->next;
		s->next=p;
		}
		while(first2->next!=NULL){
			first2=first2->next;
			node *p=(node *)malloc(sizeof(node));	//处理残余数 
			p->data=first2->data;
			p->next=s->next;
			s->next=p;
		}
		while(length2--){
			node *z=q->next;
			if(z->data==0){			//清除前导 0 
			q->next=z->next;
			free(z);
			}
		}
		result->next->data=-result->next->data;		//头部置为负	
	}
	return result;
}


void _sub(){
	char c;
	char str1[100],str2[100];
	node *first1,*first2;
	printf("请输入被减数:");
	scanf("%s",str1);
	first1=change(str1);
	printf("请输入减数:");
	scanf("%s",str2);
	first2=change(str2);
	length1=strlen(str1);
	length2=strlen(str2);
	node *result=sub(first1,first2);
	printf("结果是：");
	print(result);
	dele(first1);
	dele(first2);
	dele(result);
}

总结

  1. 熟悉了多文件编程
  2. 对链表，栈等数据结构有了更深的了解
「已注销」
关注
专栏目录
大数乘法-C语言实现
m0_54167891的博客
08-05 315
大数乘法 思路 以字符串形式读入每一个数 将每个字符转化为对应的数字，并以单链表存储 每位相乘，将得到的新链表入栈 代码实现 #include<stdio.h> #include<stdlib.h> #include<string.h> int length1=0,length2=0; typedef struct node{ int data; struct node *next; //声明链表 }node; //打印链表 void print(n
JavaScript简易计算器实现
最新发布
传播有益的技术文章，力求精准、专业、专心、专享
06-04 425
javascript实现一个简易计算器
mAP计算工具
qq_34193444的博客
06-08 454
https://github.com/Cartucho/mAP 注意input格式要求，做好转换即可
arcmap字段计算器的使用
weixin_43567883的博客
05-22 1万+
需求：某个要素类中的某个字段的数据前有空格，需将空格批量删除。 解决方法： 1.打开arcmap，添加图层，选择开始编辑（如下图） 选中图层，右键打开属性表，选择需要修改的字段，右键“字段计算器” 弹出“字段计算器”对话框，如下图，依次进行选择（strip()代表删除字段中的空格），点击确定。数据处理完毕后，可以看见选中数据的空格全部被删除了。之后保存编辑即可。 除此之外，字段计算器还可进行多种复杂的字段修改。 ...
Java 使用Map作计数器
chunhazhan5688的博客
10-31 973
很多时候我们需要对一些高频出现的词汇或……做统计。使用一个map集合很容易就能做到这一点，那么怎样做才能做高效呢？举几个例子说明： 如：从数据库读取数据或从文本文件中读取数据，统计某些字符出现的次数 //统计str中one、two、three出现的次数 Stringstr="o...
MapReduce中的计算器以及数据清理
阳哥的博客
08-15 397
一、计数器 1、概述 计数器是MR程序在运行过程中记录一些数据信息，比如 Map阶段输入了多少数据 Map阶段输出了多少数据，Combiner输入了多少数据 Combiner输出多少数据。 Hadoop为每个作业维护若干内置计数器，以描述多项指标。例如，某些计数器记录已处理的字节数和记录数，使用户可监控已处理的输入数据量和已产生的输出数据量。 2、计数器的使用：采用计数器组、计数器名称的方式统计 context.getCounter("gro...
HTML简单计算器实现
qq_43558459的博客
07-02 4551
这款计算器的主要功能有加减乘除，平方开方，清零，回退，连续加减乘除等功能。 成品图如下： 功能模块图如下： 整体用一个table标签创建一个五行六列的表格，这里上HTML代码： <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1
C++简易计算器的实现
热门推荐
wmwmwmwmwm1234的博客
10-03 1万+
计算器是近代人发明的可以进行数字运算的机器。
Android入门：简单计算器的实现
L9102fun的博客
09-04 754
在学习了基本布局和点击监听后，可以写一个简单计算器，实现基础的演算功能。
C语言简易计算器实现编写一个简易计算器
04-25
**简易计算器实现** 在计算机科学领域，学习编程语言如C语言是基础且至关重要的。本设计任务要求我们创建一个简单的计算器程序，它能够执行基本的数学运算，包括加法、减法、乘法和除法。以下是实现这个计算器程序...
简单计算器简单计算器简单计算器简单计算器简单计算器简单计算器
02-03
【标题】: "Java编程实现简单计算器" 在Java编程领域，构建一个简单的计算器是一项基础而重要的练习，它能帮助开发者熟悉基本的输入输出处理、条件判断以及数学运算。"简单计算器简单计算器简单计算器简单计算器...
Android Studio实现简易计算器
08-27
Android Studio 实现简易计算器 Android Studio 是一个功能强大且流行的集成开发环境（IDE），用于开发 Android 应用程序。在这篇文章中，我们将详细介绍如何使用 Android Studio 实现一个简易计算器，包括界面布局...
CVI简易计算器实现完整工程文件
03-28
《CVI简易计算器实现》 本项目为一个基于CVI（CodeVisionAVR）开发环境的简易计算器工程，旨在提供基本的数学运算功能，包括多位数的加、减、乘、除，同时允许用户自定义运算规则。项目还包含一个菜单栏退出功能，...
基于JAVA的简单计算器实现.rar
06-01
总的来说，这个基于Java的简单计算器实现涵盖了Java基础语法、控制流、字符串处理、GUI编程等多个方面。通过这个项目，开发者不仅可以巩固Java编程技能，还能学习到如何结合用户交互设计程序，提高软件工程实践能力...
C语言实现笛卡尔积
m0_54167891的博客
10-04 3283
简介 笛卡尔乘积是指在数学中，两个集合 X 和 Y 的笛卡尔积（Cartesian product），又称直积，表示为 X×Y，第一个对象是 X 的成员而第二个对象是* Y的所有可能有序对的其中一个成员 假设集合A={a, b}，集合B={0, 1, 2}，则两个集合的笛卡尔积为{(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}。 类似的例子有，如果A表示某学校学生的集合，B表示该学校所有课程的集合，则A与B的笛卡尔积表示所有可能的选课情况。A表示所有声母的集合
等价关系C语言实现
m0_54167891的博客
10-23 1485
数学定义 设 R 是集合 A 上的一个二元关系，若R满足： ​ 自反性：∀ a ∈A, => (a, a) ∈ R ​ 对称性：(a, b) ∈R∧ a ≠ b => (b, a)∈R ​ 传递性：(a, b)∈R,(b, c)∈R =>(a, c)∈R 则称R是定义在A上的一个等价关系。设R是一个等价关系，若(a, b) ∈ R，则称a等价于b，记作 a ~ b 程序实现 #include<stdio.h> #define N 6 /*是否自反*/ int fu1
6174数学黑洞
m0_54167891的博客
06-08 1054
6174数学黑洞 取任何一个4位数（4个数字均为同一个数字的例外），将组成该数的4个数字重新组合成可能的最大数和 可能的最小数，再将两者的差求出来；对此差值重复同样的过程（例如：开始时取数8028，最大的重新组 合数为8820，最小的为0288，二者的差8532。重复上述过程得出8532－2358=6174），最后总是达到卡普 雷卡尔黑洞：6174。称之“黑洞”是指再继续运算，都重复这个数，“逃”不出去。把以上计算过程称 为卡普雷卡尔运算，这个现象称归敛，其结果6174称归敛结果。 #include<
大数除法-C语言实现
m0_54167891的博客
08-05 768
大数除法 思路 以字符串形式读入每一个数 将每个字符转化为对应的数字，并以单链表存储 代码实现 #include<stdio.h> #include<stdlib.h> #include<math.h> #include<string.h> int length1=0,length2=0; typedef struct node{ int data; struct node *next; //声明链表 }node; //打印链表 void p
system使用
m0_54167891的博客
11-16 624
头文件 stdlib.h 函数原型 int system(const char * command) 函数功能 执行 dos(windows系统) 或 shell(Linux/Unix系统) 命令，参数字符串command为命令名。另，在windows系统下参数字符串不区分大小写 说明 在windows系统中，system函数直接在控制台调用一个command命令。 在Linux/Unix系统中，system函数会调用fork函数产生子进程，由子进程来执行command命令，命令执行完后随即返
Android简易计算器实现
"这是一个关于如何在Android平台上实现一个简单计算器应用的代码示例。" 在Android开发中，创建一个简单的计算器应用程序通常涉及到用户界面设计、事件监听以及数学运算的实现。以下是一个基本的步骤和关键知识点：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值