长整数四则运算源代码数据结构
数据结构课程设计长整数四则运算
数据结构课程设计题目：长整数四则运算班级学号学生姓名提交日期成绩计算机与通信工程学院长整数四则运算一需求分析：问题描述：设计一个实现任意长的整数进行加法运算的演示程序。
基本要求：利用双向循环链表实现长整数的存储，每个结点含一个整形变量。
任何整形变量的范围是 -(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 }。
大整数四则运算number.cpp
flag=1;
}
for (i=0;a[i];i++){
mul[i]=(a[i]-'0')*t+'0';
}
mul[i]=0;
jinwei(mul);
if (flag){
char tempn[MN];
strcpy (tempn,mul);
}
else break;
}
strcpy(t1,a);
strcpy(t2,b);
numadd(t1,t2,c);
printf ("%s+%s=%s\n\n",a,b,c);
strcpy(t1,a);
strcpy(t2,b);
numsub(t1,t2,c);
int lab=la-lb;
if (comp==0){
strcpy(sub,"0");
}
else if (comp>0){
sub[la--]=0;
for (i=lb-1;i>=0;i--){
if (a[i+lab]>=b[i]){
sub[la--]=a[i+lab]-b[i]+'0';
numadd(tempn,a,mul);
}
jinwei(mul);
int len=strlen(b);
i=strlen(mul);
while (--len){
mul[i++]='0';
}
mul[i++]=0;
数据结构实验报告——四则运算表达式求值
数据结构实验报告——四则运算表达式求值实验五四则运算表达式求值一．问题描述：四则运算表达式求值，将四则运算表达式用中缀表达式，然后转换为后缀表达式，并计算结果。
二．基本要求：使用二叉树来实现。
三．实现提示：利用二叉树后序遍历来实现表达式的转换，同时可以使用实验二的结果来求解后缀表达式的值。
输入输出格式：输入：在字符界面上输入一个中缀表达式，回车表示结束。
输出：如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。
测试实例：输入：21+23* （12-6 ）输出：21 23 12 6 -*+四．设计概要用二叉树表示表达式：若表达式为数或简单变量，则相应二叉树中仅有一个根结点，其数据域存放该表达式信息若表达式= （第一操作数）（运算符）（第二操作数），则相应的二叉树中以左子树表示第一操作数，右子树表示第二操作数，根结点的数据域存放运算符（若为一元算符，则左子树空）。
操作数本身又为表达式.后缀遍历二叉树码实现和静态检查上机调试及测试数据的调试五．源程序：#include#include#include#include#include#include#define STACK_INIT_SIZE 100#define DATA_SIZE 10#define STACKINCREMENT 10#define OK 1#define TRUE 1#define FALSE 0#define ERROR 0#define OVERFLOW -2using namespace std;typedef float SElemtype;typedef int Status;typedef char * TElemType;typedef struct BiTNode {TElemType data;int len; //data字符串中字符的个数struct BiTNode * lchild, * rchild;}BiTNode, *BiTree;typedef struct{SElemtype *base;SElemtype *top;int stacksize;} SqStack;Status IsDigital(char ch)if(ch>='0'&&ch<='9'){return 1; //是数字字母}return 0; //不是数字字母}int CrtNode(stack &PTR, char *c){BiTNode * T;int i=0;T = (BiTNode *)malloc(sizeof(BiTNode));T->data = (char *)malloc(DATA_SIZE*sizeof(char));while(IsDigital(c[i])){T->data [i] = c[i];i++;}T->len = i;T->lchild = T->rchild = NULL;PTR.push (T);return i;}void CrtSubTree(stack &PTR, char c){BiTNode * T;T = (BiTNode *)malloc(sizeof(BiTNode));T->data = (char *)malloc(DATA_SIZE*sizeof(char));T->data [0] = c;T->len = 1;T->rchild = PTR.top(); //先右子树，否则运算次序反了PTR.pop ();T->lchild = PTR.top();PTR.pop ();PTR.push (T);}char symbol[5][5]={{'>', '>', '<', '<', '>'}, //符号优先级{'>', '>', '<', '<', '>'},{'>', '>', '>', '>', '>'},{'>', '>', '>', '>', '>'},{'<', '<', '<', '<', '='}};int sym2num(char s) //返回符号对应优先级矩阵位置{switch(s){case '+': return 0; break;case '-': return 1; break;case '*': return 2; break;case '/': return 3; break;case '#': return 4; break;}}char Precede(char a, char b) //返回符号优先级{return(symbol[sym2num(a)][sym2num(b)]);void CrtExptree(BiTree &T, char exp[]){//根据字符串exp的内容构建表达式树Tstack PTR;//存放表达式树中的节点指针stack OPTR;//存放操作符char op;int i=0;OPTR.push ('#');op = OPTR.top();while( !((exp[i]=='#') && (OPTR.top()=='#')) ) //与{ if (IsDigital(exp[i])){//建立叶子节点并入栈PTRi+=CrtNode(PTR, &exp[i]);}else if (exp[i] == ' ')i++;else{switch (exp[i]){case '(': {OPTR.push (exp[i]);i++;break;}case ')': {op = OPTR.top (); OPTR.pop ();while(op!='('){CrtSubTree(PTR, op);op = OPTR.top (); OPTR.pop ();}//end whilei++;break;}default: //exp[i]是+ - * /while(! OPTR.empty ()){op = OPTR.top ();if (Precede(op, exp[i])=='>'){CrtSubTree(PTR, op);OPTR.pop ();}if(exp[i]!='#'){OPTR.push (exp[i]);i++;}break;}}//end switch}//end else}//end whileT = PTR.top();PTR.pop ();}void PostOrderTraverse(BiTree &T, char * exp ,int &count){//后序遍历表达式树T，获取树中每个结点的数据值生成逆波兰表达式exp //T是表达式树的根节点；字符串exp保存逆波兰表达式；count保存exp中字符的个数//后序遍历中，处理根结点时，依据T->len的值，把T->data中的字符依次添加到当前exp字符串的尾端//添加完T->data后，再添加一个空格字符，同时更新count计数器的值。
汇编语言加减乘除四则运算实现源代码.
汇编语言加减乘除四则运算实现源代码汇编语言加减乘除四则运算实现源代码 MOVBX,AX POP AX DIV CX PUSH DX MOV DX,BX OR BX,AX JNZ DOUT1DOUT2: POP AX ADDAL,'0' CMP AL,'9' JBEDOUT3 ADD AL,'A'-'9'-1DOUT3: CALLDISP DEC BP JNZ DOUT2 POP BP POP DX POP BX POPAX RET;输入数据在DX:AX中返回;CX=0 数据为10进制;CX#0 数据为16进制DATE LABEL NEAR PUSHBX PUSH BP PUSH DI XOR AX,AX XOR DX,DXDATE1: MOVDI,AX LODSB CMP AL,'0' JB DATE7 CMP AL,'9' JA SHL DI,1 RCL DX,1 SHL DI,1 RCL DX,1 JCXZ DATE3 SHLDI,1 RCL DX,1 Jmp shortDATE4DATE3: ADD DI,BX ADCDX,BPDATE4: ADD AX,DI ADCDX,0 JMP DATE1DATE5: ADDAL,9 JMP DATE2DATE6: JCXZDATE7 CMP AL,'A' JBDATE7 CMP AL,'F' JBEDATE5 CMP AL,'a' JBDATE7 CMP AL,'f' JBEDATE5DATE7: MOV AX,DI DECSI OR DI,DX POP DI POPBP POP BX RET;数据1与数据2根据YSF1进行加减运算JSJJ LABEL NEAR MOVAX,NUM2 MOV DX,NUM2+2 CMPYSF1,'+' JZ JSJJ1 SUBNUM1,AX SBB NUM1+2,DX JMP SHORTJSJJ2JSJJ1: ADD NUM1,AX ADC NUM1+2,DX上一页[1] [2] [3] 下一页。
长整数四则运算
一试验目的和要求1. 实验目的了解线性表的逻辑结构特性，熟练掌握线性表的链式存储结构，熟练掌握线性表在链式存储结构上实现基本操作：查找，插入，删除的算法。
能在实际应用中选用适合的链表结构。
加深对链表的本质了解。
2. 实验要求利用双向链表实现长整数的存储，每个结点含一个整型变量。
设计一个实现任意长的整数进行四则运算的演示程序。
二实验环境萨大苏打sdasd本程序可以在98/2000/XP下运行,可以用VC++6.0执行三程序的逻辑框图四, 程序源代码/*list.h*/#include<malloc.h>#include<process.h>#include<stdlib.h>#include<stdio.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASLBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior,*next;}DuLNode,*DuLinkList;//构造一个空的双向循环线性表，L为头结点Status InitList_DuL(DuLinkList &L);//在L中确定第i个元素的位置指针pDuLinkList GetElemP_DuL(DuLinkList L,int i);//在带头结点的双链循环线性表L中第i个位置之前插入元素e ,//i的合法值为1<=i<=ListLength_DuL(L)+1Status ListInsert_DuL(DuLinkList &L,int i,ElemType e);//删除带头结点的双链循环线性表L中第i个元素，i的合法值为1<=i<=ListLength_DuL(L) Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e);//若L为空表，则返回TRUE,否则返回FALSEbool ListEmpty_DuL(DuLinkList L);//线性表L已存在，返回L中数据元素个数Status ListLength_DuL(DuLinkList L);//若线性表L已存在，将L置为空表Status ClearList_DuL(DuLinkList &L);//销毁线性表LStatus DestroyList_DuL(DuLinkList &L);//用e返回L中第i个数据元素的值void GetElem_DuL(DuLinkList L,int i,ElemType &e);//返回双向循环链表L中e出现的次数int Counter_DuL(DuLinkList L,ElemType e);//返回第n个e的在链表中位置n的合法值为0<=n<=Counter_DuL( L,n)int Position_DuL(DuLinkList L,int n,ElemType e);/*function.cpp*/#include"list.h"/****************************************************************************** ********************//****************************函数声明**************************************************************//****************************************************************************** ********************/DuLinkList calculate(DuLinkList p,int*j,char *f,int *num,int k); void output(DuLinkList r);DuLinkList Pack_Up(DuLinkList r); //整理链表rvoid exchange(DuLinkList &L,int &j);DuLinkList read_r();void operate(DuLinkList p);void decride_d();int counter(int a); //计算整数位数int max(int *num,int k); //返回最大值/*list.cpp*/#include"list.h"Status InitList_DuL(DuLinkList &L){//构造一个空的双向循环线性表，L为头结点L=(DuLinkList)malloc(sizeof(DuLNode));if(!L)exit(OVERFLOW);L->next=L;L->prior=L;return OK;}//InitList_DuLDuLinkList GetElemP_DuL(DuLinkList L,int i){//在L中确定第i个元素的位置指针pDuLinkList p;p=L;for(int j=0;j<i;j++)p=p->next;return (p);}//GetElemP_DuLStatus ListInsert_DuL(DuLinkList &L,int i,ElemType e){//在带头结点的双链循环线性表L中第i个位置之后插入元素e ,//i的合法值为0<=iDuLinkList s,p;if(i<0)return OVERFLOW;else{p=GetElemP_DuL(L,i);if(!(p))return ERROR;s=(DuLinkList)malloc(sizeof(DuLNode));if(!s)return ERROR;s->data=e;s->prior=p;s->next=p->next;p->next->prior=s;p->next=s;return OK;}}//ListInsert_DuLStatus ListDelete_DuL(DuLinkList &L,int i,ElemType &e){//删除带头结点的双链循环线性表L中第i个元素，i的合法值为1<=i<=ListLength_DuL(L)DuLinkList p;if(!(p=GetElemP_DuL(L,i))||p==L)return ERROR;e=p->data;p->prior->next=p->next;p->next->prior=p->prior;free(p);return OK;}//ListDelete_DuLbool ListEmpty_DuL(DuLinkList L){//若L为空表，则返回TRUE,否则返回FALSEif(L->prior==L->next)return TRUE;else return FALSE;}//listElemty_DuLStatus ListLength_DuL(DuLinkList L){//线性表L已存在，返回L中数据元素个数int i=0;DuLinkList p=NULL;for(p=L;p->next!=L;p=p->next)i++;return (i);}//ListLength_DuLStatus ClearList_DuL(DuLinkList &L){//若线性表L已存在，将L置为空表ElemType e;if(!ListEmpty_DuL(L))for(int i=1;i<=ListLength_DuL(L);i++)ListDelete_DuL(L,i,e);return OK;}//ClearList_DuLStatus DestroyList_DuL(DuLinkList &L){//销毁线性表LElemType e;if(!ListEmpty_DuL(L))for(int i=1;i<=ListLength_DuL(L);i++)ListDelete_DuL(L,i,e);free(L);return OK;}//DestroyList_DuLvoid GetElem_DuL(DuLinkList L,int i,ElemType &e){//用e返回L中第i个数据元素的值if(i<0||i>ListLength_DuL(L))printf("The Function GetElem_Sq() found Nothing in this position\n");elsee=GetElemP_DuL(L,i)->data;}//GetElem_DuLint Counter_DuL(DuLinkList L,ElemType e){//返回双向循环链表L中e出现的次数int i;DuLinkList p=NULL;for(i=0,p=L;p->next!=L;p=p->next)if(p->data==e)i++;return i+1;}//Counter_DuLint Position_DuL(DuLinkList L,int n,ElemType e){//返回第n个e的在链表中位置n的合法值为0<n<=Counter_DuL( L,n) int i,j;DuLinkList p=NULL;if(n<1||n>Counter_DuL(L,e))return OVERFLOW;else{for(i=0,j=0,p=L->next;p!=L;p=p->next){j++;if(p->data==';')i++;if(i==n)break;}return (j);}//else}//Position_DuL/*decride.cpp*/#include<stdio.h>void decride_d(){printf("*************************************************************\n");printf("*注意!! 请严格按照国家对于长整数的表示习惯: \n");printf("*即每四位一组;组间用\',\'隔开\';\'每个数以\";\"结束\n");printf("*否则可能导致系统运行出错!!! \n");printf("**************************************************************\n");printf("输入N:退出,按任意键继续,回车进行计算!\n");printf("**************************************************************\n"); }/*ExChange.cpp*/#include"function.h"#include<math.h>void exchange(DuLinkList &L,int &j){int i=0,sum=0;DuLinkList t;ElemType e;for(i=j,sum=0;i>0;i--){t=GetElemP_DuL(L,ListLength_DuL(L));sum+=((int)t->data-48)*(int)pow(10.0,(double)(j-i));ListDelete_DuL(L,ListLength_DuL(L),e);}ListInsert_DuL(L,ListLength_DuL(L),sum);j=0;}//exchange/*Operration.cpp*/#include"function.h"/****************************************************************************** ********************//****************************操作函数operate(DuLinkList )******************************************//****************************************************************************** ********************/void operate(DuLinkList p){DuLinkList q;int k=0,i=0,n=0;k=Counter_DuL(p,';');int *j=(int *)malloc(k*sizeof(int));char *f=(char *)malloc(k*sizeof(char));int *num=(int *)malloc(k*sizeof(int));for(i=0;i<k;) //分号的位置j[i-1]=Position_DuL(p,++i,';');if(p->next->data=='-')f[0]='-'; //判断正负数else f[0]='+';for(i=1;i<k;i++){if(GetElemP_DuL(p,j[i-1])->next->data=='-')f[i]='-';else f[i]='+';}for(q=p,i=0;i<k;i++){n=0;q=q->next;for(;q!=GetElemP_DuL(p,j[i]);q=q->next)if(q->data==',')n++;num[i]=n+1;}output(Pack_Up(calculate(p,j,f,num,k)));free(j);free(f);free(num);DestroyList_DuL(p);}//operate/*------------------------------------------------------------------------------------------------------*/ DuLinkList calculate(DuLinkList p,int*j,char *f,int *num,int k) //计算{DuLinkList r;int sum=0,i=0,t=0,m=0,ma=0,JW=0;InitList_DuL(r);for(JW=0,m=0,ma=max(num,k);m<=ma;m++){for(i=0,sum=0;i<k;i++){if(num[i]<=0);else{t=(f[i]=='-'?-1:1);if(GetElemP_DuL(p,j[i]-1)->data==',')j[i]-=1;sum+=t*GetElemP_DuL(p,j[i]-1)->data;num[i]--;}}//forfor(i=i-1;i>=0;i--)j[i]-=1;if((sum+JW)<10000&&(sum+JW)>-10000){ListInsert_DuL(r,0,sum+JW);JW=0;}else {ListInsert_DuL(r,0,(sum+JW)%10000);JW=(sum+JW)/10000;} }//for}//calculate/*------------------------------------------------------------------------------------------------------*/ DuLinkList Pack_Up(DuLinkList r) //整理链表r {ElemType e;int i=0;for(i=1;i<ListLength_DuL(r);i++){if(GetElemP_DuL(r,1)->data==0)ListDelete_DuL(r,1,e);else break;}//for 清零。
长整数四则运算加减法
青岛理工大学数据结构课程设计报告题目：长整数四则运算院（系）：计算机工程学院学生姓名:班级：学号:起迄日期:指导教师: 房斐斐2012—2013年度第 2 学期一、需求分析1.问题描述：设计一个实现任意长的整数进行加、减法运算的演示程序。
2.基本功能1、本程序实现计算任意长的整数的加、减法运算. 以用户和计算机对话的方式，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令，然后程序就计算并显示出这两个数的运算。
2、本演示程序中，集合的元素限定为数字字符[‘0’~’9’]和字符‘，’与‘；’，输入字符可以任意长，输入形式以“回车符”为结束标志，串中字符顺序不限，且允许出现重复字符。
3、利用双向循环链表现实长整数的存储，每个结点含一个整形变量。
输入的形式以回车结束，可以直接输入正数或负数。
按中国对于长整数的表示习惯，每四位一组，除数字和位于首位置的负号外，其它一切字符都将作为分隔符，连续多个分隔符当一个处理。
但不使用分隔符也不影响结果。
3.输入输出（1）0；0；加法应输出“0”，减法应输出”0”。
（2）-2345,6789；-7654,3211；加法应输出“-1,0000,0000”，减法应输出”5408,6422”。
（3）-9999,9999；1,0000,0000,0000；加法应输出“9999,0000,0001”，减法应输出1,0000,9999,9999。
（4）1,0001,0001；-1,0001,0001；加法应输出“0”，减法应输出”2,0002,0002”。
（5）1,0001,0001；-1,0001,0000；加法应输出“1”，减法应输出”2,0002,0001”。
（6）-9999,9999,9999；-9999,9999,9999；加法应输出“1,9999,9999,9998”，减法应输出”0”。
（7）1,0000,9999,9999；1；加法应输出“1,0001,0000,0000”，减法应输出”1,0000,9999,9998”。
数据结构课程设计长的整数加法
数据结构课程设计题目名称：长的整数加法计算机科学与技术学院一、需求分析1.问题描述：设计一个程序实现两个任意长的整数的求和运算。
2.基本要求：利用双向循环链表，设计一个实现任意长的整数进行加法运算的演示程序。
要求输入和输出每四位一组，组间用逗号隔开。
如：1，0000，0000，0000，0000。
3.任务陈述：(a)输入的形式和输入值的范围：本实验中演示中，长整数的每位上的数字必须为数字[0——9]之间，长整数的位数要求无限长。
测试的时候输入数据，当输入回车键的时候结束输入，如果输入的字符不符合题目要求，则程序能过滤这些不符合要求的字符。
(b)输出的形式:整数的范围无限制，可为正数，可为负数。
按照中国对于长整数的表示习惯，每四位是一组，组间用逗号隔开。
(c) 程序所能达到的功能:演示程序以用户和计算机的对话方式执行，即在计算机显示“提示信息”后之后，由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据和运算结果显示在其后，并对错误。
（d）测试数据:①—⑧为正确输入数据，⑨为错误输入数据(超出4位)，⑩为错误输入数据(不足4位)。
①两长整数a=b=0请按照如下形式输入第一个长整数，每四位一组: -1234,1234,1234--------按该模式输入0 --------输入长整数a您的输入结果为:0 --------显示a(防止错误输入)请按照如下形式输入第一个长整数，每四位一组: -1234,1234,1234--------输入长整数b 您的输入结果为:您的运算结果为:0 --------输出②b>a>0请按照如下形式输入第一个长整数，每四位一组: -1234,1234,12341,1111,1111,1111您的输入结果为:1,1111,1111,1111请按照如下形式输入第二个长整数，每四位一组: -1234,1234,12349,9999,9999,9999您的输入结果为:9,9999,9999,9999您的运算结果为:11,1111,1111,1110③a>b>0请按照如下形式输入第一个长整数，每四位一组: -1234,1234,1234 9999,9999,9999您的输入结果为:9999,9999,9999请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234 2您的输入结果为:2您的运算结果为:1,0000,0000,0001④b<a<0请按照如下形式输入第一个长整数，每四位一组: -1234,1234,1234 -2345,6789您的输入结果为:-2345,6789请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234 -7654,3211您的输入结果为:-7654,3211您的运算结果为:－1,0000,0000⑤a<0,b>0,|a|>|b|请按照如下形式输入第一个长整数，每四位一组: -1234,1234,1234 -1,0000,00001您的输入结果为:-1,0000,0001请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234 2您的输入结果为:2您的运算结果为:-9999,9999⑥a<0,b>0,|a|<|b|请按照如下形式输入第一个长整数，每四位一组: -1234,1234,1234 -9999您的输入结果为:-9999请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234 1,0000您的输入结果为:1,0000您的运算结果为:1⑦a>0,b<0,|a|>|b|请按照如下形式输入第二个长整数，每四位一组: -1234,1234,12341,0000,0000您的输入结果为:1,0000,0000请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234-9999您的输入结果为:-9999您的运算结果为:9999,0001⑧a>0,b<0,|a|<|b|请按照如下形式输入第一个长整数，每四位一组: -1234,1234,12341您的输入结果为:1请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234-1,0000,0000您的输入结果为:-1,0000,0000您的运算结果为:-9999,9999⑨错误输入（例：输入超过四位，则自动取其前四位进行运算）请按照如下形式输入第一个长整数，每四位一组: -1234,1234,12341,00000您的输入结果为:1,0000请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234-99998,01234您的输入结果为:-9999,1234您的运算结果为:-9998,1234⑩错误输入（例：非第一次输入少于四位，则在输入前加0补足四位进行运算）请按照如下形式输入第一个长整数，每四位一组: -1234,1234,12341,000您的输入结果为:1,0000请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234-1,11您的输入结果为:-1,0011您的运算结果为:-11二、概要设计1.目标需求与设计思想通过尾插输入长整数，为实现顺序存入，并用头插存储的运算后的长整数，因为运算必定从后向前计算，同样为了实现顺序存入。
用C语言实现超长整数的加减乘除四则运算
q= q > nex t;
}
© 1995-2005 Tsinghua Tongfang Optical Disc Co., Ltd. All rights reserved.
·3 8· (总 284) 用 C 语言实现超长整数的加减乘除四则运算 2003 年
} if (i 1) 加数、被加数均已结束, 最高位有进位 { h= m a lloc (sizeof (struct node) ) ; h > data= 1; h > nex t= hc > nex t; hc > nex t= h; q= q > nex t; } link to str (hc, s) ; 将加和链表转换为字符串 delink (ha) ; delink (hb) ; delink (hc) ; retu rn s;
c++实现任意长整数的四则运算
实验题目：设计一数据结构可处理任意长度的整数概要设计1.数据结构的定义采用双向链表存储任意长整数。
双向链表的定义如下：class DblList {private:DblNode *head, *tail;DblNode *current;int sign;public:DblList(); //构造函数~DblList(); //析构函数bool CreatList(string); //生成一个双向链表，存储整数int GetCount(); //获取整数的长度void Insert(DblNode *); //从表尾插入一个结点void InsertFront(DblNode *); //从表头插入void Clear(); //清除该链表void operator+(DblList &); //实现两个任意整数的加法void operator*(DblList &); //实现两个任意整数的乘法DblList & operator=(DblList &); //重载赋值运算符int Compare(DblList &); //两个整数的绝对值比较void Display(); //任意长度整数的标准化输出};说明:数据的存储，无外乎顺序或者链表。
顺序存储时，定义数组无法实现任意长度，而且需要预设一个maxsize，不是特别的方便。
所以采用链式存储方式。
而且任意长数据通过字符串输入。
在链表的每一个结点中，数据域是在该数位上的数字大小。
2．主要功能模块的功能◆任意长整数的输入◆任意长整数的标准化输出◆两个整数的加法◆两个整数的乘法三．详细设计（主模块流程图）五、使用说明及测试结果1.使用说明：点击打开应用程序pro1.exe。
依次输入任意两个整数（例如123456，+1234567），按回车，会出现菜单，如下图：按‘1’则实现两整数的加法按‘2’则实现两整数的乘法按‘#’结束注：菜单可重复出现直至‘#’退出。
- 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相加的操作。