长整数四则运算源代码数据结构
数据结构课程设计长整数四则运算
数据结构课程设计题目：长整数四则运算班级学号学生姓名提交日期成绩计算机与通信工程学院长整数四则运算一需求分析：问题描述：设计一个实现任意长的整数进行加法运算的演示程序。
基本要求：利用双向循环链表实现长整数的存储，每个结点含一个整形变量。
任何整形变量的范围是 -(2^15 - 1) (2^15 - 1)。
输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。
在现实生活中有很多地方，例如航空航海、生物医疗等等方面，都需要很大的数来表示，这些用int甚至长整型long long都是远不够的，所以需要有一种算法来解决这种大数的表示和运算。
该问题只要求了大数的相加运算。
二详细设计：大致思路：【存储】用两个链表，每个节点保存一位数，在链表头保存数的正负，正数保存1，负数保存-1，如果是正数，后面每一位都储存正数，负数每一位都储存负数，数字按照链表头到链表尾从高位到低位的顺序；【相加】从两个链表的尾部开始同步向前相加，加完存到第一个链表，第二个加完的结点销毁，会存在两个链表不一样长的情况，没加的直接连到链表的前面，最高位的符号存到链表的头；【调整】根据表头的符号，调整后面的数字的值，中间会产生进位或者退位的问题，各个节点的符号不一定相同，但对于正负数都可以建立同样的调整模式，将正负到tmp中（1或-1）加或者减(tmp*10)，然后对前一位加或者减tmp*1即可。
第一位保留符号不变，这样不用处理多余的进位，也就不用再产生新的节点，也不用保存符号。
【输出】从前到后遍历已经处理好的表，将每一位进行输出就可以了。
结构体定义struct Node{Node *pre;Node *next;int data;};功能函数void Input(Node *p,Node *t)//处理输入和保存void disply(Node *h,Node *t,int l)//输出void add(Node *h1,Node *t1,Node *h2,Node *t2)//每一位相加int adjust(Node *h,Node *t)//将各个位的正负、大小、进位进行调整源程序：。
四则运算 数据结构
//用数据结构编写简单四则运算（+,-,*,/）//整体思路（可带多个括号，及小数）//建立一个单向链表//运算过程中运算符优先级# = ) + - * / (// 0 0 1 2 2 3 3 4// while(p->data && GetTop(OPTR))// { (p->data)// if(数字) 进栈OVS// else if(GetTop(OPTR)!='(' && p->data!=')')// {// if(GetTop(OPTR) 低于p->data 优先级)// 进栈OPTR// else// while(GetTop(OPTR) 高于p->data 优先级) // 运算// }// else 删去左右括号// }//字符转换为数字(用一个数组表示数字)//#include<stdio.h>#include<math.h>#include<conio.h>#include<io.h>#include<ctype.h>#include<stdlib.h>#include<string.h>#define N 5#define M 60typedef char ElemType;typedef struct node{ElemType data;struct node *next;}*LinkList, Node;typedef struct fnode{float data;struct fnode *next;}*FLinkList, FNode;LinkList BuildLink(char str[M]); //建立链表LinkList Push_char(LinkList L, ElemType data); //进入符号栈int IsEmpty(LinkList L); //栈是否为空ElemType GetTop(LinkList L); //取出符号栈顶栈不删除ElemType Pop_char(LinkList L, ElemType *x); //取出符号栈顶栈删除float Pop_float(FLinkList L, float *x); //取出数字栈顶栈删除int BracketMatch(char *e); //判断括号匹配float Execute(float m, char op, float n); //进行简单运算int Compare(char a); //比较运算符优先级float ExpEvaluation(LinkList L); //进行（可以括号，小数）的运算int Get_number(char ch); //字符转换为数字int GetNumber_1(int b[N], int i); //取整数部分float GetNumber_2(int b[N], int i); //取小数部分void Start(){LinkList L;float x;char str[M];printf("请输入运算式（'='结束）\n");gets(str); //puts(str);BracketMatch(str);L = BuildLink(str);// BracketMatch(L); printf("ok2");x = ExpEvaluation(L);printf("上式运算结果为wei:");printf("%f\n", x);}LinkList BuildLink(char str[M]){LinkList L;Node *p,*s;int i;L = (LinkList)malloc(sizeof(Node));L->next=NULL;p = L;for(i=0; str[i]; i++){s = (Node*)malloc(sizeof(Node));s->data = str[i];p->next = s;p = s;}return L;}LinkList Push_char(LinkList L, ElemType data) {Node *temp;temp = (Node*)malloc(sizeof(Node));temp->data = data;temp->next = L->next;L->next = temp;return L;}FLinkList Push_float(FLinkList OVS, float data) {FNode *temp;temp = (FNode*)malloc(sizeof(FNode));temp->data = data;temp->next = OVS->next;OVS->next = temp;return OVS;}int IsEmpty(LinkList L){if(L->next == NULL)return 1;elsereturn 0;}ElemType GetTop(LinkList L){ElemType *x;Node *p;p = L->next;x = &p->data;*x = p->data;return *x;}ElemType Pop_char(LinkList L, ElemType *x){Node *p;p = L->next;*x = p->data;L->next = p->next;free(p);return *x;}float Pop_float(FLinkList L, float *x){FNode *p;p = L->next;*x = p->data;L->next = p->next;free(p);return *x;}int BracketMatch(char *e){int i,count=0,flag=1;char c;for(i=0;c=e[i];i++){if((c>='0'&&c<='9')||c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='.'||c=='#' || c=='=');else{system("cls");printf("表达式中含非法字符，请重新输入：");Start();}if(count==0&&c==')'){system("cls");printf("右括号多余，请重新输入：");Start();}else if(c=='(')count++;else if(c==')')count--;}if(count!=0){system("cls");printf("左括号多余，请重新输入：");Start();}return flag;}float Execute(float m, char op, float n){float x;switch(op){case'+': x = m + n; break;case'-': x = n - m; break;case'*': x = m * n; break;case'/':{if(m)x = n / m;else{system("cls");printf("式中除数为零！！请重新输入\n");Start();}break;}default: break;}return x;}int Compare(char a){if(a == '#' || a == '=') return 0;else if(a == ')') return 1;else if(a == '+' || a == '-') return 2;else if(a == '*' || a == '/') return 3;else if(a == '(') return 4;else{system("cls");printf("输入运算符错误！！请重新输入\n");Start();return -1;}}int Get_number(char ch){int x;switch(ch){case'0': x = 0; break;case'1': x = 1; break;case'2': x = 2; break;case'3': x = 3; break;case'4': x = 4; break;case'5': x = 5; break;case'6': x = 6; break;case'7': x = 7; break;case'8': x = 8; break;case'9': x = 9; break;default: break;}return x;}int GetNumber_1(int b[N], int i) {int j,k,t;int x=0;for(k=0; k<=i; k++){t = 1;for(j=1; j<i-k; j++)t = 10*t;x = x+b[k]*t;}return x;}float GetNumber_2(int b[N], int i) {int j,k;float x=0,t;for(k=0; k<=i; k++){t = (float)(0.1);for(j=0; j<i; j++)t = (float)(0.1*t);x = x+b[k]*t;}return x;}float ExpEvaluation(LinkList L) {LinkList OPTR;FLinkList OVS;int Dkey=0,key=1;int i,j;int x_1;float x,x_2,m,n;int b[N],a[N];Node *p;char op,ch;p = L->next;OPTR = (LinkList)malloc(sizeof(Node));OVS = (FLinkList)malloc(sizeof(FNode));OVS->next=NULL;Push_char(OPTR,'#');while(p->data!= '=' || GetTop(OPTR)!= '#'){if('0'<=p->data && p->data<='9'){i = 0;while('0'<=p->data && p->data<='9'){a[i] = Get_number(p->data);p = p->next;i++;}a[i] = 0;x_1 = GetNumber_1(a,i);if(p->data == '.'){j = 0;Dkey = 1;p = p->next;while('0'<=p->data && p->data<='9'){b[j] = Get_number(p->data);p = p->next;j++;}b[j] = 0;x_2 = GetNumber_2(b,j);}if(Dkey)Dkey = 0;elsex_2 = 0;x = x_1 + x_2;Push_float(OVS, x);}else{if(GetTop(OPTR)!='(' || p->data!=')'){if(GetTop(OPTR) == '(')Push_char(OPTR, p->data);else if((Compare(p->data) - Compare(GetTop(OPTR))) > 0)Push_char(OPTR, p->data);elseif((Compare(p->data) - Compare(GetTop(OPTR))) <= 0){key=0;Pop_char(OPTR, &op);Pop_float(OVS, &m);Pop_float(OVS, &n);x = Execute(m, op, n);Push_float(OVS, x);}}else if(OVS->next != NULL)Pop_char(OPTR,&ch);else{system("cls");printf("输入错误!! 括号中无数字请重新输入\n");Start();}if(key==1)p = p->next;if(key==0)key=1;}}Pop_float(OVS,&x);return x;}void main(){Start();}。
实验报告长整数四则运算
实验报告：长整数四则运算实验者：唐怡04120082 题目：设计一个实现任意长的整数进行加法运算的演示程序一．需求分析1．本演示程序中，长整数为任意长的带符号的长整数的输入及求加法后输出的长整数形式为每四位一组，组间用逗号隔开，输入以“回车符”为结束标志。
2．程度执行的命令包括：1）构造整数1，2）构造整数2，3）做加法运算，4）结束3．测试数据（1）0；0；应输出“0”（2）-2345，6789；-7654，3211；应输出“-1，0000，0000”（3）-9999，9999；1，0000，0000，0000；应输出“9999，0000，0001”（4）1，0001，0001；-1，0001，0001；应输出“0”（5）1，0001，0001；-1，0001，0000；应输出“1”（6）-9999，9999，9999；-9999，9999，9999；应输出“-1，9999，9999，9998”（7）1，0000，9999，9999；1；应输出“1，0001，0000，0000”。
二．概要设计为实现上述程序功能，应以有序表实现长整数的存储，为此，需要抽象数据类型：有序表1．有序表的抽象数据类型定义为：ADT Dulinklist{数据对象：D={ai|ai为带符号整数，1，2,…,n,n>=0}数据关系：R1={<ai-1,ai>|ai-1,ai属于集合D,ai-1<ai,i=2,…..,n}基本操作：InitDulinklist(&)操作结果：构造一个空的有序表LDestroyDulinklist(&)初始条件：有序表L已存在操作结果：销毁有序表LDulinklistLength(L)初始条件：有序表L已存在操作结果：返回有序表L的长度DulinklistEmpty(L)初始条件：有序表L已存在操作结果：若有序表L为空表，则返回TUER，否则返回FALSEGetElem(L,pos)初始条件：有序表L已存在操作结果：若干1〈=POS〈=LENGTH（L），则返回有序表L中第POS个数据元素。
长整数四则运算源代码 数据结构
{
if(num[j]!=0 || (str[0]=='-' && str[1]!='\0')||(str[0]!='-' && str[0]!='\0'))
//此判断语句是为了避免输出诸如：00123…的情况
str[i++]=num[j]+'0';
scanf("%s",str);
getchar();
flag=conversion(str,opr2);
while(!flag)
{
printf("ERROR!Input again:\n");
scanf("%s",str);
getchar();
return -1;
else//长度相等的情况
{
while(p1->data==p2->data && p1->next!=opr1)//注意不要少了p1->next!=opr1这个条件
{
p1=p1->next;
opri->next->prior=opri;
while(!flag)
{
printf("ERROR!Input again:\n");
scanf("%s",str);
getchar();
flag=conversion(str,opr1);
}
printf("\n请输入第二个操作数:\n");
1长整数四则运算+数据结构课程设计
[实验名称]长整数四则运算[需求分析]设计一个实现任意长的整数进行减法运算的演示程序，要求完成长整数的加减运算，乘除运算可选做。
在这里长整数没有范围限制，可任意长。
运算后的进位、借位等都要进行正确处理，可实现动态的输入，实时的输出。
测试数据：0、0；输出“0”2345，6789、-7654，3211；输出“1，0000，0000”1，0000，0000，0000、9999，9999；输出“9999，0000，0001”1，0001，0001、；1，0001，0001；输出“0”自选数据：1,2345,6789; 9,8765,4321；输出“11,1111,1110”[概要设计]数据结构利用双向循环链表来实现对长整数的存储。
每个节点只存储四位十进制数字，即不超过9999的非负整数。
双向链表有头指针，它的data值存储长整数的符号，1为正，-1为负，0代表长整数为0；它的over值存储除头节点外节点的个数。
其他节点的data 值存储四位整数，over存储该四位整数溢出0~~9999范围的情况，一般over>0表示四位数超出9999，over<0表示四位数小于0。
选择该数据结构来完成长整数的加减运算是因为要对长整数进行运算，需要对长整数进行存储，所以选择用链表对长整数存储，又由于存储的顺序是从左到右，而运算的顺序则是从右到左，这样位了操作方便选择循环链表，在运算过程中有进位和借位的操作，所以最终选择双向循环链表的数据结构。
[详细设计]typedef struct DoubleNode //定义链表元素void InitNode(DLNode **head) //初始化链表int InsertNode(DLNode *head,int n,DataType x) //向链表第N个位置插入元素Xint digit(int n) //判断整数N有几位void PrintNode(DLNode *head) //打印链表void DestroyNode(DLNode **head)//销毁链表void add(DLNode *h1,DLNode *h2) //两数相加void jian(DLNode *h1,DLNode *h2) //两数相减int main() //入口函数[调试分析]调试过程中的困难：在数据的运算中，应为是根据数的大小来选择运算的，所以过程相对比较繁琐。
长整数四则运算+数据结构课程设计
长整数四则运算+数据结构课程设计长整数四则运算题目：编制一个演示长整数的四则运算的程序一、需求分析1. 本程序实现计算任意长的整数的四则运算. 以用户和计算机对话的方式，先后输入数字的最多位数，然后程序就计算并显示出这两个数的运算。
2. 利用双向循环链表现实长整数的存储，每个结点含一个整形变量。
输入的形式以回车结束，可以直接输入正数或负数，程序会过滤掉无效的字符。
按中国对于长整数的表示习惯，每四位一组，除数字和位于首位置的负号外，其它一切字符都将作为分隔符，连续多个分隔符当一个处理。
但不使用分隔符也不影响结果。
3. 测试数据(1)0; 0; 输出“0”;(2)-2345,6789; -7654,3211; 输出“-1,000,000”;(3)-9999,9999; 1,0000,0000,0000; 输出“9999,0000,0001”;(4)1,0001,0001; -1,0001,0001; 输出“0”;(5)1,0001,0001; -1,0001,0001; 输出“1”;(6)-9999,9999,9999; -9999,9999,9999; 输出“-1,9999,9999,9998”;(7)1,0000,9999,9999; 1; 输出"1,0001,0000,0000".二、概要设计为实现上述程序功能，应以双向循环链表表示长整数。
为此，需要定义一个抽象数据类型。
1.抽象数据类型定义为：ADT OrderedList{2.数据对象：D={ai|ai∈int,i=1,2,...n, n≥0}基本操作：init(&a,digit4)操作结果：构造一个位数是digit4*4长整数。
pass(&a,&b,&c)初始条件：a,b,c都已存在操作结果：c等于a和b的和。
nep(&a)初始条件：a已存在。
操作结果：a变为输入参数的相反数。
printlong(&a)初始条件：a已存在。
大数据结构课程设计(长整数四则运算
一、需求分析1.本程序实现计算任意长的整数的四则运算.以用户和计算机对话的方式，先后输入数字的最多位数，然后程序就计算并显示出这两个数的运算。
2.利用双向循环链表现实长整数的存储，每个结点含一个整形变量。
输入的形式以回车结束，可以直接输入正数或负数，程序会过滤掉无效的字符。
按中国对于长整数的表示习惯，每四位一组，除数字和位于首位置的负号外，其它一切字符都将作为分隔符，连续多个分隔符当一个处理。
但不使用分隔符也不影响结果。
3.测试数据(1)0; 0;输出“0”;(2)-2345,6789; -7654,3211;输出“-1,000,000”;(3)-9999,9999; 1,0000,0000,0000;输出“9999,0000,0001”; (4)1,0001,0001; -1,0001,0001;输出“0”;(5)1,0001,0001; -1,0001,0001;输出“1”;(6)-9999,9999,9999;-9999,9999,9999;输出“-1,9999,9999,9998”; (7)1,0000,9999,9999; 1;输出"1,0001,0000,0000".二、概要设计为实现上述程序功能，应以双向循环链表表示长整数。
为此，需要定义一个抽象数据类型。
1.抽象数据类型定义为：ADT OrderedList{数据对象：D={ai|ai∈int,i=1,2,...n, n≥0}基本操作：init(&a,digit4)操作结果：构造一个位数是digit4*4长整数。
pass(&a,&b,&c)初始条件：a,b,c都已存在操作结果：c等于a和b的和。
nep(&a)初始条件：a已存在。
操作结果：a变为输入参数的相反数。
printlong(&a)初始条件：a已存在。
操作结果：按四位一组，分隔符为","的格式，在屏幕上输出a。
长整数四则运算+阶乘+乘方=数据结构课程设计(保证原创性)
数据结构课程设计报告题目：长整数四则运算学院计算机学院专业计算机科学与技术年级班别2010级四班学号3110006015学生姓名张法光指导教师张巍成绩____________________2012年6月一、需求分析1、设计一个实现任意长的整数进行四则运算的程序。
2、利用双向循环链表实现长整数的存储，每个结点含一个整型变量。
3、输入和输出形式是按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开，长整数位数没有上限，以分号结束长整型数据的输入。
4、实现长整数四则运算、阶乘和乘方运算。
4、测试数据：（以加法为例）（1）、0;0;+;应输出“0”。
（2）、－2345,6789;－7654,3211;+;应输出“－1,0000,0000”。
（3）、－9999,9999;1,0000,0000,0000;+;应输出“9999,0000,0001”.（4）、1,0001,0001;－1,0001,0001;+;应输出“0”.（5）、1,0001,0001;－1,0001,0000;+;应输出“1”。
（6）、－9999,9999,9999;－9999,9999,9999;+;应输出“－1,9999,9999,9998”.（7）1,0000,9999,9999;1;+;应输出“1,0001,0000,0000”.二、概要设计为了实现上述功能，采取双向循环链表表示长整数，每个结点含一个整型变量，且仅绝对值不超过9999的整数，整个链表用十进制数表示。
利用头结点数据域的符号表示长整数的符号，相加过程不破坏两个操作数链表，对长整数位数不作上限。
为此需要两个结构数据类型：双向循环链表和长整数，两个类型采用相同的结构，只是双向循环链表用来存储数据，长整型用表示数据的运算。
1、双向循环链表的数据结构及操作定义如下：typedef int Status;typedef int ElemType;typedef struct DuLNode //双向循环链表结点{ElemType data;struct DuLNode * prior;struct DuLNode * next;}DuLNode,* DuLinkList;typedef struct //双向循环链表{DuLinkList head; //双向循环链表头结点，不存放数据int len; //双向循环链表中的结点个数，头结点不计}LinkList;基本操作：Status InitList(LinkList &L);//构造一个空的线性链表void ClearList(LinkList &L);//将线性链表L重置为空表，并释放原链表的结点空间Status HeadInser(LinkList &L,ElemType e);//在线性链表的头结点后插入数据元素为e的新结点Status TailInser(LinkList &L,ElemType e);//在线性链表的头结点前插入数据元素为e的新结点Status HeadDelete(LinkList &L);//删除头结点后的第一个结点Status ListCopy(LinkList &L,LinkList L1);//将L1复制给L，保持L1不变2、长整数的数据类型和和操作定义为：void ScanNum(LinkList &L);//从键盘输入一个长整数，存至L;void PrintNum(LinkList L);//在屏幕打印长整数Lvoid NumChange(LinkList &L);//将长整数L还原成一般格式Status NumLarger(LinkList L1,LinkList L2);//比较正数L1与正数L2的大小，若L1大于或等于L2，返回TRUE，否则返回FALSE void NumPlus(LinkList L1,LinkList L2,LinkList &L3);//将L1与L2相加，结果存至L3; 即C=A+B；void NumMinus(LinkList L1,LinkList L2,LinkList &L3);//计算L1减去L2的值，结果存至L3；即C=A-B;void NumMul(LinkList L1,LinkList L2,LinkList &L3);//将L1与L2相乘，结果存至L3；即C=A*B;Status NumDiv(LinkList L1,LinkList L2,LinkList &L3,LinkList &L4);即C=A/B;//计算L1除以L2，商存至L3，余数存至L4，若L2为零，返回ERROR，否则返回OKStatus jiecheng(LinkList L1,LinkList &L2)即C=A！；//求L1的阶乘L2；若L1小于零，返还ERROR；否则返回OK；Status chengfang(LinkList L1,LinkList L2,LinkList &L3) 即C=A^B;//求L1的L2次方的结果，若L2小于零，返还ERROR；否则返回OK；3、本程序包含四个模块：1）主程序模块：void main( ) //main.c{初始化；do{接受命令；处理命令；}while(“命令”=“结束”)｝2）双向循环链表处理模块//LinkList.h;3）长整数运算模块//LongNum.h ,jiecheng.h , chengfang.h;4）界面模块 //Interface.h各模块之间的调用关系如下：主程序模块==========================================长整数运算模块界面模块======================双向循环链表处理模块=======================三、详细设计1、主要函数主程序模块//main.c双向循环链表处理模块//LinkList.h长整数四则运算模块//LongNum.h阶乘运算模块//jiecheng.h乘方运算模块//chengfang.h界面模块//Interface.hchar ShowMenu() //界面菜单显示char ShowPlus() //加法运算显示char ShowMinus() //减法运算显示char ShowMul() //乘法运算显示char ShowDiv() //除法运算显示char Showchengfang()//乘方运算显示char Showjiecheng() //阶乘运算显示2、函数的主要调用关系图InitList ClearList Interface=============================ShowScanNumJiecheng chengfang NumMinus NumChange======================================================================四、调试分析及编程心得体会刚开始使用C指针有偏颇，通过逐步调试修正错误。
数据结构课程设计---长整数运算
数据结构课程设计－－－长整数运算没有测试，代码仅供参考！！！1：需求分析用户输入2个任意长整数，求它们的加法，减法和乘法，并将结果显示；2：设计思想a：数据结构的选用为了实现任意长整数的加法，减法和乘法，因为这几种运算都存在进位和借位以及位移等操作，因此选择双链表的结构体，它有一个data，left，right；考虑到data表示的数据的范围，使它只接受4个数字的整数，这样一个长整数就分为若干段，每一段为4个数字，便于进位和借位以及位移的操作；b：2个长整数的输入首先输入数的正负号，将它转化为相应的0和1；接着采用头插法的方式，当输入一个4个数字的整数时，就产生一个新的节点，它的值为输入的整数值，建立起它的左右指针，并用头节点指向它；为了判断一个长整数是否输入结束，定义一个结束标志，当输入正数时就继续，当输入负数时，就结束一个长整数的输入；同时用一个函数得到长整数的尾节点和段数，段数在比较2个数的大小有用。
c：2个长整数的加法先定义一个部分加法的函数，就是2个正的长整数的加法的运算；它从2个长整数的尾部开始，同时相加，接着再向左移一段，又同时相加；当2个数据的某一段同时存在时，就相加；当一个数据已经全部被相加后，另外一个数据的剩下的段就要全部复制到和中；在实行加法的时候，设置一个进位标志位，目的是为了使结果正确；当一段的数据相加产生进位时，那么进位标志位为1；下一次一段的数据相加就要加上这个进位标志位；而且如果2个长整数的所有的段的数据都相加完了，还要判断是否产生了进位标志位，如果有的话，就要新建一个节点，它的值就是1；2个正的长整数的求和就完成了。
再定义一个部分减法的函数，就是2个正的长整数的减法的运算；第一个长整数的大小一定大于第二个长整数的大小；它从2个长整数的尾部开始，同时相减，接着再向左移一段，又同时相减；当2个数据的某一段同时存在时，就相加；当第二个长整数已经全部被相减后，第一个数据的剩下的段就要全部复制到结果中；在实行减法的时候，设置一个借位标志位，目的是为了使结果正确；当一段的数据相减产生借位时，那么借位标志位为1；下一次一段的数据相减就要借去这个进位标志位；2个正的长整数的减法就完成了。
C语言实现大数四则运算
C语⾔实现⼤数四则运算⼀、简介众所周知，C语⾔中INT类型是有限制，不能进⾏超过其范围的运算，⽽如果采⽤float类型进⾏运算，由于float在内存中特殊的存储形式，⼜失去了计算的进度。
要解决整个问题，⼀种解决⽅法是通过字符串数组实现数据的存储，然后实现它们之间四则运算的函数。
⼆、数据结构为了实现字符数组之间的运算，要考虑数值的正负性，数字的长度以及具体存储的数字typedef struct num{int len; //数值长度char symbol; //数字正负形int number[LEN]; //数组}NUM,*SNUM;三、函数整个程序使⽤了⼀下的函数SNUM expToNum(char exp[]);//将输⼊字符串转换为对应结构体void reverse(int a[],int len);//数组逆序int compareAbs(SNUM left,SNUM right);//⽐较两数绝对值⼤⼩SNUM anti_add(SNUM left,SNUM right);//元加法SNUM anti_sub(SNUM left,SNUM right);//元减法SNUM add(SNUM left,SNUM right); //加法SNUM sub(SNUM left,SNUM right); //减法SNUM multiply(SNUM left,SNUM right); //乘法SNUM divide(SNUM left,SNUM right); //除法SNUM mod(SNUM left,SNUM right);//求摸运算函数的定义1 SNUM multiply(SNUM left,SNUM right){2//left作为被乘数，right作为乘数3 SNUM mul = (struct num*)malloc(sizeof(struct num));4int i,j;5for(i=0;i<LEN;i++){6 mul->number[i]=0;7 }89if(left->symbol==right->symbol){10 mul->symbol='+';11 }else{12 mul->symbol='-';13 }14151617for(i=0;i<right->len;i++){18for(j=0;j<left->len;j++){19 mul->number[i+j]+=left->number[j]*right->number[i];20 }21 }22232425////进位化简26int len = left->len+right->len-1; //长度2728//29for(i=0;i<len;i++){30 mul->number[i+1]+=mul->number[i]/10;31 mul->number[i]%=10;3233if(i==len-1){34if(mul->number[i+1]!=0){ //还存在⾼位35 len++;36 }else{ //进位完毕，退出37break;38 }39 }40 }4145for(i=len-1;i>=0;i--){46if(mul->number[i]==0){47 len--;48 }else{49break;50 }51 }52if(len==0){53 len=1;54 }5556 mul->len=len;5758free(left);59free(right);60return mul;61 }62636465//减⼀个数等于加上⼀个数的相反数66 SNUM sub(SNUM left,SNUM right){67 right->symbol=(right->symbol=='+'?'-':'+');68return add(left,right);69 }7071//⽐较两数绝对值⼤⼩72int compareAbs(SNUM left,SNUM right){73if(left->len>right->len){ //left的位数更多74return1;75 }else if(left->len<right->len){ //right的位数更多76return -1;77 }else{78int i=left->len-1;79while(i>=0){ //从⾼位开始⽐较80if(left->number[i]>right->number[i]){81return1;82 }83if(left->number[i]<right->number[i]){84return -1;85 }86 i--;87 }88return0; //两者绝对值相等89 }90 }919293 SNUM expToNum(char exp[]){9495 SNUM temp=(struct num*)malloc(sizeof(struct num)); 9697int locan=0;98//确定正负号99if(exp[0]=='+'||exp[0]=='-'){100 temp->symbol=exp[0];101 locan++;102 }else{103 temp->symbol='+';104 }105106//输⼊到数组107int count=0;108while(exp[locan]!='\0'){109 temp->number[count]=exp[locan]-'0';110 locan++;111 count++;112 }113114int i=count;115for(i=count;i<LEN-1;i++){116 temp->number[i]=0;117 }118119 temp->len=count;120121122//数组逆序从个位开始计算123 reverse(temp->number,temp->len);124125return temp;129void reverse(int a[],int len){130int i,temp;131for(i=0;i<len/2;i++){132 temp = a[i];133 a[i] = a[len-1-i];134 a[len-1-i] = temp;135 }136 }137138139140//元加法，假设left和right都为正数或0141 SNUM anti_add(SNUM left,SNUM right){142int i=0;143144while(i<left->len||i<right->len){145int sum=0;146 sum=left->number[i]+right->number[i]; 147if(sum>=10){148 left->number[i]=sum%10;149 left->number[i+1]+=sum/10; //进位150 }else{151 left->number[i]=sum; //不进位152 }153154 i++;155 }156157if(left->number[i]!=0){158 i+=1;159 }160161 left->len=i;162return left;163 }164165//实现正数或负数的加法166 SNUM add(SNUM left,SNUM right){167 SNUM temp;168if(left->symbol==right->symbol){169 temp = anti_add(left,right);170 }else{171if(compareAbs(left,right)>=0){172 temp = anti_sub(left,right);173174 }else{175 temp = anti_sub(right,left);176 }177 }178return temp;179 }180181//元减法,假设left>=right，left和right均为正数或0 182 SNUM anti_sub(SNUM left,SNUM right){183int i=0;184int count=0;185while(i<left->len){186int temp = left->number[i]-right->number[i]; 187if(temp<0){188 left->number[i+1]-=1;189 left->number[i]=temp+10; //退位190 }else{191 left->number[i]=temp;192 }193194 count+=1;195196 i++;197 }198199200201202//舍掉多余的0203for(i=count-1;i>=0;i--){204if(left->number[i]==0){205 count--;206 }else{207break;208 }213 }214215 left->len=count; 216return left;217218 }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
长整数四则运算源代码数据结构// 长整数四则运算.cpp : 定义控制台应用程序的入口点。
//#include <stdafx.h>#include<cstdio>#include<cstring>#include<malloc.h>#include<conio.h>#include<stdlib.h>#define LEN sizeof(struct Node)#define MAX 1000#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE 0typedef int Status;typedef struct Node{int data;struct Node *prior,*next;}Node,*NodeList;//=======================================输入模块=========================================//求指数函数值int axp(int a,int k){int r=1;if(k==0)return 1;for(;k>0;k--)r=r*a;return r;}//输入转换函数Status conversion(char str[],NodeList &oprh){//将字符串形式的操作数转换成所需的类型int i,k,buffer;k=buffer=0;oprh=(NodeList)malloc(LEN);oprh->next=oprh;oprh->prior=oprh;for(i=strlen(str)-1;i>=0;i--){//若输入的数不合法就返回重新输入if((i!=0 || (str[0]!='-' && str[0]!='+'))&&(str[i]>'9' || str[i]<'0'))return ERROR;if(str[0]=='0' && str[1]!='\0')return ERROR;if((str[0]=='-' || str[0]=='+') && str[1]=='0')return ERROR;if(str[i]!='-' && str[i]!='+'){buffer=buffer+(str[i]-'0')*axp(10,k);k++;if(k==4 || str[i-1]=='-' || str[i-1]=='+' || i==0){//将新建结点插入到头结点之后p=(NodeList)malloc(LEN);oprh->next->prior=p;p->prior=oprh;p->next=oprh->next;oprh->next=p;p->data=buffer;buffer=k=0;}}}if(str[0]=='-')oprh->data='-';elseoprh->data='+';return OK;}//输入函数Status input(NodeList &opr1,NodeList &opr2,char str[]){printf("\n请输入第一个操作数:\n");scanf("%s",str);getchar();flag=conversion(str,opr1);while(!flag){printf("ERROR!Input again:\n");scanf("%s",str);getchar();flag=conversion(str,opr1);}printf("\n请输入第二个操作数:\n");scanf("%s",str);getchar();flag=conversion(str,opr2);while(!flag){printf("ERROR!Input again:\n");scanf("%s",str);getchar();flag=conversion(str,opr2);}return OK;}//=================================================================== =====================//=======================================输出模块=========================================//输出函数Status output(NodeList oprr,char str[]){Status initbuf(char str[]);NodeList p;int i,j,num[4];if(!oprr)return ERROR;p=oprr;i=j=0;initbuf(str);if(oprr->data=='-')str[i++]='-';p=p->next;if(p->next==oprr && p->data==0)//若要输出的数为0则执行str[i++]='0';elsewhile(p!=oprr){num[0]=p->data/1000;num[1]=(p->data-num[0]*1000)/100;num[2]=(p->data-num[0]*1000-num[1]*100)/10;num[3]=p->data-num[0]*1000-num[1]*100-num[2]*10;while(j<4){if(num[j]!=0 || (str[0]=='-' && str[1]!='\0')||(str[0]!='-' && str[0]!='\0')) //此判断语句是为了避免输出诸如：00123…的情况str[i++]=num[j]+'0';j++;}p=p->next;j=0;}str[i]='\0';printf("%s",str);printf("\n");return OK;}//=================================================================== =====================//==================================预处理及杂项操作模块==================================//缓冲区部分初始化函数Status initbuf(char str[]){int i;for(i=0;i<=10;i++)str[i]='\0';return OK;}//比较链表长度函数int cmplinklen(NodeList opr1,NodeList opr2){//opr1链比opr2链长则返回1，短则返回-1，否则返回0 NodeList p1,p2;p1=opr1->prior;p2=opr2->prior;while(p1->prior!=opr1 && p2->prior!=opr2) {p1=p1->prior;p2=p2->prior;}if(p1->prior!=opr1)return 1;if(p2->prior!=opr2)return -1;return 0;}//求链表长度int length(NodeList oprr){int count=0;NodeList p=oprr->next;while(p!=oprr){count++;p=p->next;}return count;}//生成指定长度链表Status Creat(NodeList &oprr,int len){NodeList p;oprr=(NodeList)malloc(LEN);p=oprr;while(len>0){p->next=(NodeList)malloc(LEN);p->next->data='?';p->next->prior=p;p=p->next;len--;}p->next=oprr;oprr->prior=p;return OK;}//比较opr1、opr2绝对值的大小int compare(NodeList opr1,NodeList opr2){NodeList p1,p2;p1=opr1->next;p2=opr2->next;if(cmplinklen(opr1,opr2)==1)//opr1比较长return 1;else if(cmplinklen(opr1,opr2)==-1)//opr2比较长return -1;else//长度相等的情况{while(p1->data==p2->data && p1->next!=opr1)//注意不要少了p1->next!=opr1这个条件{p1=p1->next;p2=p2->next;}if(p1->data>p2->data)return 1;else if(p1->data<p2->data)return -1;elsereturn 0;}}//-----------------------初始化链表函数-----------------------Status init(NodeList &oppr){oppr=NULL;return OK;}//init//销毁链表函数Status distroy(NodeList &oprr){NodeList q;if(oprr){q=oprr->next;while(q!=oprr){free(q->prior);q=q->next;}}oprr=NULL;return OK;}//distroy//链表短赋值函数Status evaluate(NodeList &opri,int i){//将i的值转换成万进制类型，i为整形变量opri=(NodeList)malloc(LEN);opri->data='+';opri->next=(NodeList)malloc(LEN);opri->next->data=i;opri->next->next=opri;opri->prior=opri->next;opri->next->prior=opri;return OK;}//evaluate//=================================================================== =====================//=======================================加减法模块=======================================//加法基本操作Status add_bas(NodeList opr1,NodeList opr2,NodeList &oprr){//本算法实现A,B相加的操作。