大数据结构课程设计(长整数四则运算)

合集下载

数据结构课程设计长整数四则运算

数据结构课程设计长整数四则运算

数据结构课程设计题目:长整数四则运算班级学号学生姓名提交日期成绩计算机与通信工程学院长整数四则运算一需求分析:问题描述:设计一个实现任意长的整数进行加法运算的演示程序。

基本要求:利用双向循环链表实现长整数的存储,每个结点含一个整形变量。

任何整形变量的范围是 -(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)//将各个位的正负、大小、进位进行调整源程序:。

长整数四则运算 实验报告

长整数四则运算 实验报告

“数据结构”课程设计报告长整数四则运算学生姓名:吴成杰徐文良指导教师:陈少军所在系:电子信息系所学专业:计算机科学与技术年级:2010计算机(1)班目录第1章需求分析 (1)1.1选题要求 (1)1.2选题背景和意义 (1)1.3选题目标 (2)1.4组员分配任务 (2)第2章概要分析 (2)2.1系统数据流图 (2)2.2原始数据 (3)2.3输出数据 (3)2.4对数据的处理 (3)2.5数据结构(存储方式) (4)2.6模块分析 (4)第3章详细设计 (4)第4章系统说明书 (11)第5章系统测试 (12)项目总结 (16)参考文献 (17)第1章需求分析1.1选题要求1、实现一个任意长度的整数进行四则运算的演示程序(1) 运算过程分步骤显示(2) 完成含有加法和减法的四则运算(3) 完成含有乘法和除法的四则运算(4) 包含括号的四则运算2、2个人对应完成2个人各自的任务1.2选题背景和意义(1)选题背景操作系统老师曾经布置我们做一道斐波拉契数列和求30的阶乘,但是计算的结果很大,还不知道该做样的存储,老师告诉我们需要用高精度数的知识能将计算的结果存储起来,数据结构老师也曾经布置过一个实验题,是计算长整数的加法的,但是长整数的位数是固定的。

于是我们试想计算任意长度的整数是不是能把所有的四则运算问题解决。

(2)选题意义我们选的这个课题能计算任意的四则运算,比如:1234567+7654321=8888888987654321-123456789=86419754123*456=5608884/42=2586-25*15+8*(9*2-144/12)=586-375+8*(18-12)=586-375+8*6=586-355+48=211+48=2591.3选题目标实现一个任意长度的整数进行四则运算的演示程序(1) 运算过程分步骤显示(2) 完成含有加法和减法的四则运算(3) 完成含有乘法和除法的四则运算(4) 包含括号的四则运算1.4组员分配任务我们组有两个成员,分别为吴成杰和徐文良,一个负责写主函数、函数整体的框架和写转换函数函数和对输入的字符进行处理,一个负责写出栈函数和写处理函数和拼接,程序出现错误,两个人一起在一起互相商量,修改。

计算机软件及应用课程设计实验报告长整型数四则运算

计算机软件及应用课程设计实验报告长整型数四则运算

数据结构实验报告题目:长整型数四则运算学院计算机学院专业软件工程年级班别2010级1班成绩____________________2012年7月1日目录课程设计实验报告1一、实验概要- 1 -二、实验目的- 1 -三、实验环境- 1 -四、抽象数据类型的定义- 1 -五、存储结构的定义- 1 -六、算法设计- 2 -六、程序运行情况- 30 -七、实验总结- 33 -实验中遇到的问题:-33-实验总结:-33-八、思考题错误!未定义书签。

题目:长整型数四则运算一、实验概要1、设计一个实现任意长的整数进行四则运算的程序。

2、输入和输出形式是按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开,长整数位数没有上限,以分号结束长整型数据的输入。

3、程序执行的命令包括:1)、输入长整数1;2)、输入长整数2;3)、输入执行的运算符;4)、计算并输出结果;5)、结束。

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”.二、实验目的输入和输出形式是按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开,长整数位数没有上限,以分号结束长整型数据的输入,进行计算三、实验环境Visual C++6.0四、抽象数据类型的定义1、双向循环链表的数据结构及操作定义如下:typedef short ElemType; //定义基本数据类型,我们采用short来表示任意4位整数。

数据结构课程设计长整数加减运算

数据结构课程设计长整数加减运算

课程名称数据结构课程设计题目长整数加减运算一、需求分析设计一个实现任意长的整数间进行四则运算的程序,要求完成长整数的加运算和减运算。

长整数的长度没有限制,可以是任意长。

正确处理好运算之后的进位和借位。

(1)输入:[-]**,****,****;[-]*,****,****,**** //[-]表示“-”可选(2)输出:**,****,****,****是否继续计算(Y/N):(3)功能:能正确进行相关数据的加减运算(4)测试数据:0;0;输出“0”2345,6789;7654,3211;输出“1,0000,0000”1,0000,0000,0000;-9999,9999;输出“9999,0000,0001”1,0001,00001;-1,0001,0000;输出“0”自选数据二、概要设计1、使用双向循环链表实现长整数的运算及存储,构造双向循环链表,创建双向循环链表表示两个整数2、设计两整数相加的函数Add(),addtwo(),其中Add()调用addtwo()函数,addtwo()具体实现两个整数的加减操作,进位及借位问题;设计显示函数Display()及主函数main()三、详细设计1、数据结构设计双向循环链表的构造t ypedef struct LinkNode{int data; //记录每个节点的整数(小于)LinkNode *next, *pre; //记录下一个节点的地址和前一个节点的地址}linklist;2、创建两个长整数的链表伪算法void Creat(char a[]) //引入字符串,创立两个链表,分别表示两个整数{int 记录字符串i;记录加数节点数j;记录被加数节点数s;标记字符串中的‘-’号记录字符串中的字符转化为整数的值k,使每个节点记录位l while(指针所指不是“;”)被加数字符数m自动加1 //m记录字符串中被加数的字符数n=m;while(执政没有指到结尾处) 总字符串n位数自动加1; //n记录字符串的总字符数if被加数不是负数{head0->data=(-1); //记录整数符号w=1;}else {head0->data=1;}for(i=m-1;i>=w;i--){If指针所指为数字,而不是“,” //把字符转化为整数{k+=(a[i]-'0')*sum(l); //sum()计算的乘方l++;}if(a[i]==','||i==w){把整数存到双向循环链表中s++; //节点数加k=0; //重新初始化k和ll=0;}}head0->pre->data*=s; //存储整数符号和节点数}四、调试分析a、调试过程中,连续输入数字运算,速度会明显变慢,发现在初始化链表及运算后没有释放链表,造成系统资源浪费,经改造后自爱后面添加了析构函数b、算法的时空分析创建整数链表有三个循环,次数都为n。

大数据结构课程设计(长整数四则运算

大数据结构课程设计(长整数四则运算

一、需求分析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指针有偏颇,通过逐步调试修正错误。

数据结构综合实训长整数四则运算

数据结构综合实训长整数四则运算

4
长整数四则运算实现
长整数四则运算实现
加法
对于加法,我们需要从低位到高位依次相加。如果结果大于等于10,我们需要进位。我们 可以使用链表或数组来实现这个算法
链表加法示例代码(Python)
THANK YOU
2
数据结构选择
数据结构选择
链表
链表是一种动态数据结构,可以根据需要随时增加或减少节点。链表中的每个节点包含两 部分:数据和指向下一个节点的指针。使用链表可以方便地实现长整数的每一位的存储和 操作
数据结构选择
数组
数组是一种静态数据 结构,其大小在创建 时确定,不能更改。 对于长整数,我们可 以使用数组来表示每 一位数字,从而实现 大数的存储和运算
20XX
数据结构综合实训 -长整数四则运算
时 间:20XX-XX-XX
-
1 2 3 4
1
引言
引言
在计算机科学中,长整数四则运算是一 个经典问题
由于计算机的整数类型通常有固定的范 围,在进行大数运算时,必须采用特殊 的数据结构和技术来处理
本实训将介绍如何使用链表和数组来实 现长整数的表示和四则运算
数据结构选择
3
长整数表示
长整数表示
链表表示法
我们可以将长整数表示为一个链表,其中 每个节点存储一个数字(0-9)。例如,数 字123可以表示为1->2->3。链表的头部表 示整数的低位,尾部表示高位
长整数表示
数组表示串中的每个字符存储在数 组的一个元素中。例如,数字123可以表示为array [ 0]=1, array [ 1]=2, array [ 2]=3

大数据结构课程设计长整数运算

大数据结构课程设计长整数运算

一、需求分析【问题描述】设计一个程序实现两个任意长的整数求和运算。

【基本要求】利用双向循环链表实现长整数的存储,每个结点含一个整型变量。

任何整型变量的范围是:-(215-1)~(215-1)。

输入和输出形式:按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开。

【测试数据】(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”。

二、设计1. 设计思想(1)存储结构:循环双向链表(2)主要算法基本思想:1、每个结点中可以存放的最大整数为215-1=32767,才能保证两数相加不会溢出。

但若这样存,即相当于按32768进制数存,在十进制数与32768进制数之间的转换十分不方便。

故可以在每个结点中仅存十进制数4位,即不超过9999的非负整数,整个链表视为万进制数。

2、可以利用头结点数据域的符号代表长整数的符号。

用其绝对值表示元素结点数目。

相加过程中不要破坏两个操作数链表。

两操作数的头指针存于指针数组中是简化程序结构的一种方法。

不能给长整数位数规定上限。

2. 设计表示(1)函数调用关系图:(2)函数接口规格说明:结构体:struct dl_node{int x;dl_node *pre;dl_node *next;};初始化:void list_init(dl_node ** h)插入元素:void list_insert(dl_node *h,int x)输出链表:void prin(dl_node *h)实现相加:void list_add(dl_node *h1,dl_node *h2)实现相减:void list_sub(dl_node *h1,dl_node *h2)3. 详细设计(1)输入两个数,用链表来存储。

课程设计 长整数四则运算

课程设计 长整数四则运算

课程设计实验报告:1.4长整数四则运算题目:长整数四则运算一、实验内容【问题描述】设计一个实现任意长的整数进行加法运算的演示程序【基本要求】利用双向循环链表实现长整数的存储,每个结点含一个整形变量。

任何整形变量的范围是-(2八15-1)〜(2八15-1)。

输入和输出形式:按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开。

【实现基本功能】⑴是想长整数的四则运算;(ii)实现长整数的乘方和阶乘运算;(iii)整形量范围是-(2沏-1)~(2八n-1),其中n是由程序读入的参量。

输入数据的分组方法另行规定;【实现加强版本的功能】⑴四则运算在原来版本的基础上支持小数运算,除法还可以通过输入整数后加小数点与相应要求取的精确位数求出精确值,如:求取3666除以7的后三位精确值,可以在输入时将除数输入为3666.000或3666.0000,就能得出相应的精确位数,当然求取后,没有余数的输出;(ii)乘方的功能也进行了强化,支持小数操作;(iii)添加了多个出错处理(即输入重操作)对相应数据输入与输出进行提示;【加强版的实现原理】⑴加减法运算加强:在原来版本的基础上依照基本的加减法操作将数据用小数点进行分隔,记录下连个输入数的小数位长度,并将小数位较短的一个数据后补0直至小数位数相同,然后用函数处理输出的数据;(ii)乘除法、乘方:其处理方法较为简单,主要是记录数据中小数位数的长度,然后通过每种运算方式不同的运算原理截取小数位,再按照输出格式将数据处理进行输出;(iii)根据定义,阶乘保持不变;【特色分析】⑴加强版程序加上了简单的声音提示,无论是输入与输出均会有八个音符的其中之一对输入与输出与否进行提示,同时在输入输出数据出错时,还会用三个音符对重输入进行提示,增强了人性化操作;【测试数据】(1)0;0;应输出“0”。

(2)-2345,6789;-7654,3211;应输出“-1,0000,0000”。

(3)-9999,9999;1,0000,0000,0000;应输出“9999,0000,0001”。

大整数地运算大数据结构课程设计

大整数地运算大数据结构课程设计

目录一、题目概述〔内容与要求〕2二、功能分析2三、设计3四、运行与测试4五、总结21六、参考文献21一、题目概述〔内容与要求〕内容:请设计一个有效的算法,可以进展两个n位大整数的四如此运算。

①长整数长度在二十位以上。

②实现两长整数的加、减、乘、除操作。

要求:1.设计数据结构,存储结构;2.在c兼容环境完成上述题目的代码编写与调试;3.程序运行界面交互性好;4.软件运行,给出测试数据。

二、功能分析1.设计一个实现长整数进展四如此运算的程序,长整数长度在二十位以上,有正负数的区别。

2.输入每四位一组,组间用逗号隔开,长整数位数没有上限,以分号完毕长整型数据的输入。

用lnode结点数据结构存储数据。

每一个数据有一个头结点,它的data域用来放数据的正负数。

其余结点的数都为正整数。

3.程序包含数据的输入,判断,运算,输出和主函数。

4.具体程序执行的命令包括:a)输入函数:inputa();inputb();//的输入并建立双向循环链表b)判断函数:pare();//比拟数据的大小c)运算函数:unsigndeadd();//无符号的加法a)unsigndesub();//无符号的减法b)add();sub();mul();div();//加减乘除四如此运算d)输出函数:divput();//除法结果的输出函数a)putoutc();//其余结果的输出函数e)主函数:main();5.系统功能结构框图系统功能结构框图三、设计首先要考虑的是如何表示长整型数。

可以4位数形成1组,而一个长整型数可能会有很多组这种4位数,而每节之间是有先后顺序的,因此我们可以考虑用数组和链表来存储数据。

(1)再考虑到每个长整型数的长度在输入之间是无法预知的,因此使用链表在存储空间的分配上更方便一些。

(2)在输入数据时总是从高位到低位地存储,而计算时总是从低位向高位运算,因此采用双向链表更方便,而为了从头结点方便地转到尾结点可以采用循环链表。

长整数四则运算

长整数四则运算

山东理工大学计算机学院课程设计(数据结构)班级计科0503班姓名王新政学号0512105988指导教师肖爱梅张艳华二○○七年七月十三日课程设计任务书及成绩评定课题名称长整数四则运算Ⅰ、题目的目的和要求:设计中要求综合运用所学知识,上机解决一些与实际应用结合紧密的、规模较大的问题,通过分析、设计、编码、调试等各环节的训练,使学生深刻理解、牢固掌握数据结构和算法设计技术,掌握分析、解决实际问题的能力。

通过这次设计,要求在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面,加深对课程基本内容的理解。

同时,在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。

Ⅱ、设计进度及完成情况Ⅲ、主要参考文献及资料[1]严蔚敏,吴伟民主编. 《数据结构》(C语言版).清华大学出版社. 2002[2] 殷人昆等著. 《数据结构》(C++版). 清华大学出版社. 2001[3] 金远平著. 《数据结构》(C++描述). 清华大学出版社. 2005[4] Frank M.Carrano 等著. 《数据结构与C++高级教程》.清华大学出版社. 2004[5] 严蔚敏,吴伟民主编. 《数据结构习题集》(C语言版).清华大学出版社. 2002学科部主任___________(签字)Ⅳ、成绩评定:设计成绩:(教师填写)指导老师:(签字)二○○七年七月十三日目录第一章概述 (1)第二章系统分析 (2)第三章概要设计 (3)第四章详细设计与源程序 (4)第五章调试过程中的问题及系统测试情况 (12)第六章结束语 (13)参考文献 (14)第一章概述课程设计是实践性教学中的一个重要环节,它以某一课程为基础,可以涉及和课程相关的各个方面,是一门独立于课程之外的特殊课程。

课程设计是让同学们对所学的课程更全面的学习和应用,理解和掌握课程的相关知识。

《数据结构》是一门重要的专业基础课,是计算机理论和应用的核心基础课程。

大整数地运算大数据结构课程设计

大整数地运算大数据结构课程设计

目录一、题目概述(内容及要求) (2)二、功能分析 (2)三、设计 (3)四、运行与测试 (4)五、总结 (21)六、参考文献 (21)一、题目概述(内容及要求)内容:请设计一个有效的算法,可以进行两个n位大整数的四则运算。

①长整数长度在二十位以上。

②实现两长整数的加、减、乘、除操作。

要求:1.设计数据结构,存储结构;2.在c兼容环境完成上述题目的代码编写与调试;3.程序运行界面交互性好;4.软件运行,给出测试数据。

二、功能分析1.设计一个实现长整数进行四则运算的程序,长整数长度在二十位以上,有正负数的区别。

2.输入每四位一组,组间用逗号隔开,长整数位数没有上限,以分号结束长整型数据的输入。

用lnode结点数据结构存储数据。

每一个数据有一个头结点,它的data域用来放数据的正负数。

其余结点的数都为正整数。

3.程序包含数据的输入,判断,运算,输出和主函数。

4.具体程序执行的命令包括:a)输入函数:inputa();inputb();//的输入并建立双向循环链表b)判断函数:compare();//比较数据的大小c)运算函数:unsigndeadd();//无符号的加法a)unsigndesub();//无符号的减法b)add();sub();mul();div();//加减乘除四则运算d)输出函数:divput();//除法结果的输出函数a)putoutc();//其余结果的输出函数e)主函数:main();5.系统功能结构框图图2.1 系统功能结构框图三、设计首先要考虑的是如何表示长整型数。

可以4位数形成1组,而一个长整型数可能会有很多组这种4位数,而每节之间是有先后顺序的,因此我们可以考虑用数组和链表来存储数据。

(1)再考虑到每个长整型数的长度在输入之间是无法预知的,因此使用链表在存储空间的分配上更方便一些。

(2)在输入数据时总是从高位到低位地存储,而计算时总是从低位向高位运算,因此采用双向链表更方便,而为了从头结点方便地转到尾结点可以采用循环链表。

数据结构课程设计报告长整数运算

数据结构课程设计报告长整数运算

数据结构课程设计报告题目:长整数四则运算一、需求分析1. 问题描述:由于工程上有时候需要对很大的数进行计算,但是计算机本身提供的数据类型无法保存几百位甚至几千位的数字,所以需要设计专门的算法对数据进行相应的计算。

此程序的设计任务是:设计一个程序能够实现长整数运算的程序,而且能够对一些错误异常进行辨别调整,计算出正确的结果。

程序输入格式是字符串,保存时需要用双向循环链表将字符串每四位保存在循环链表中的一个节点中,然后再计算后运行出结果。

2. 基本功能功能一:建立双向循环链表,计算链表个数,对链表的数据进行修改,能在链表中插入结点。

功能二:将字符串转换成相应的数字存储在双向循环链表中功能三:对存入双向循环链表的长整数进行相加,相减,相除。

3. 输入输出程序输入以字符串的形式输入,数据的类型是字符串,包含元素的范围是数字,逗号,负号。

输入时用字符串输入,输出时以一链表结点输出,而且每个结点表示四位。

二、概要设计1. 设计思路:由于计算机无法完成位数很大的数字计算,设计思路就是将很长的数据进行分割,一部分一部分的用计算机固有数据类型进行计算。

将各部分的结果整合起来。

由于计算机固有的整数类型存数的对大整数是2人15-1 ,所以为了方便,且符合中国人对长整数的表示习惯,建立一个双向循环链表,每个结点存储四位数字,以万为进制。

从最低位开始加法,超过一万向上进位,所以每次加法应该是对应两个结点和进位数相加,进位值初始为0 ;减法也是一个结点计算一次,每次计算应该是第一个链表对应的结点值减去第二个结点的值和借位值的和,借位值初始值为0 ;除法的计算可以借助减法,被减数被减数减一次则最终结果加一;直至被减数比减数小。

2. 数据结构设计:因为计算的是一个连续的数字,需要桉顺序一次计算,所以采用的数据结构的逻辑结构是线性表。

因为要求每一个结点只存储四位数字,为了将数字连接起来,采用的数据结构的存储结构是链式。

1.双向循环链表的抽象数据类型定义为:ADT Link{数据对象:D={ai | ai € CharSet , i=1 , 2 , .......... , n, n > 0}数据关系;R={<ai-1,ai> | ai-1,ai € D,i=2 , ............ , n}}基本操作:InitLinkList(&L,a) 操作结果:构造一个双向循环链表L ,用a 判断是正数还是负数DestroyList(&L)初始条件:双向循环两已经存在操作结果:销毁有序表LInsert(&L,a) 初始条件:双向循环链表已经存在操作结果:在循环链表的末尾插入一个结点,且此结点的数据值为 a HeadInsert(&L,a)初始条件:双向循环链表已经存在操作结果:在循环链表的头结点后插入一个结点,且此结点的数据值为 a CountNode(&L)初始条件:双向循环链表存在操作结果:计算出链表中结点的个数,并返回个数Compare(&L1, &L2) 初始条件:L1 和L2 存在操作结果:比较两个双向循环链表的大小,用返回值 1 表示L1 大于L2, 返回值-1 标志L1 小于L2, 返回值0 标志L1 和L2 相等ToNum(*s,i,&e)初始条件:s 为字符串中指向某个字符的指针操作结果:将s 的前i 个字符转换为数字,存入 e 中CreatNum(&L,&s)初始条件:s 为某个字符串,双向循环链表L 存在操作结果:将字符串s 转换成数字存入到循环链表L 中Add(L1 ,L2, op)初始条件:双向循环链表L1 和L2 存在,op 为结果的标识符操作结果:两个链表相加,求出结果。

长整数四则运算实验报告

长整数四则运算实验报告

数据结构课内实验报告书一、实验题目:长整数四则运算二、实验目的:通过本次实验,熟练掌握链表的存储结构及其各种基本运算,体会链表操作的特点。

三、实验要求:设计一个实现任意长的整数进行加法运算的演示程序。

要求:利用双向循环链表实现长整数的存储,每个结点含一个整形变量。

任何整形变量的范围是-(215 - 1)~(215 - 1)。

输入和输出形式:按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开。

四、测试数据:(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)存储结构的定义typedef struct int72 {int i[4];} INT72;INT72 a,b,c;typedef struct LinkNode{int data; //记录每个节点的整数(小于10000)LinkNode *next, *pre; //记录下一个节点的地址 *pre; //记录前一个节点的地址}linklist;(2)主要算法的描述void addtwo()//节点多的作为被加数,少的作为加数,实现整数绝对值大的加小的//默认head0存的整数绝对值比head1大{int s=0,m1=head0->data,m2=head1->data;m1=(head0->pre->data/abs(head0->pre->data)); //head0的符号m2=(head1->pre->data/abs(head1->pre->data)); //head1的符号linklist *p=head0->pre->pre,*q=head1->pre->pre;result->data=head0->pre->data; //存结果的节点数和符号while(q!=head1->pre)//head0存的整数绝对值比head1大,即head0的节点数大于或等于head1 {currptr=(linklist *)malloc(sizeof(linklist));currptr->data=(p->data)*m1+(q->data)*m2+s; //两整数相加if((m1*m2)>0) //如果符号相同{if(abs(currptr->data)-10000>=0) //相加后超过10000,则进位{s=currptr->data/10000;currptr->data=abs(currptr->data)%10000;}else //abs(currptr->data)-10000<0,不进位{s=0;currptr->data=abs(currptr->data);}}else if(m1>0&&m2<0)//符号不同,在此相当于实现两个正整数相减{s=0;if(currptr->data<0) //小于0,向前一位借1{currptr->data+=10000;s=-1;}}else if(m1<0&&m2>0)//符号不同,在此相当于实现负整数加上正整数{s=0;if(currptr->data>0) //大于0,{currptr->data=10000-currptr->data;s=1;}else currptr->data=abs(currptr->data);}currptr->next=result; //存入链表currptr->pre=result->pre;result->pre->next=currptr;result->pre=currptr;result=currptr;p=p->pre;q=q->pre;}//当head0节点数比head1长时,继续建链while(p!=head0->pre){currptr=(linklist *)malloc(sizeof(linklist)); currptr->data=p->data+s;s=currptr->data/10000;if((m1*m2)>0){if(abs(currptr->data)-10000>=0){s=currptr->data/10000;currptr->data=abs(currptr->data)%10000;}else {s=0;currptr->data=abs(currptr->data);} }else if(m1>0&&m2<0){s=0;if(currptr->data<0){currptr->data+=10000;s=-1;}}else if(m1<0&&m2>0){s=0;if(currptr->data>0){currptr->data=10000-currptr->data;s=1;}else currptr->data=abs(currptr->data);}currptr->data=abs(currptr->data)%10000; currptr->next=result;currptr->pre=result->pre;result->pre->next=currptr;result->pre=currptr;result=currptr;p=p->pre;}if(s!=0) //处理相加后,进位问题{currptr=(linklist *)malloc(sizeof(linklist));currptr->data=abs(s);currptr->next=result;currptr->pre=result->pre;result->pre->next=currptr;result->pre=currptr;result=currptr;result->pre->data=m1*(abs(result->pre->data)+1);}}六、技巧与体会在编写程序中尽量做到独立完成、对于自己想要完成的问题要主动编程完成、这样自己是一个很大的提升、也能学到很多的知识、熟练编程!以后要加强动手时间能力、多与同学交流算法精髓!。

长整数四则运算

长整数四则运算

一试验目的和要求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 清零。

2长整数四则运算 数据结构课程设计[精品]

2长整数四则运算 数据结构课程设计[精品]

2长整数四则运算数据结构课程设计[精品] [实验名称]长整数四则运算[需求分析]设计一个实现任意长的整数进行减法运算的演示程序,要求完成长整数的加减运算,乘除运算可选做。

在这里长整数没有范围限制,可任意长。

运算后的进位、借位等都要进行正确处理,可实现动态的输入,实时的输出。

测试数据:0、0; 输出“0”-7654,3211; 输出“1,0000,0000” 2345,6789、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.设计思路:由于计算机无法完成位数很大的数字计算,设计思路就是将很长的数据进行分割,一部分一部分的用计算机固有数据类型进行计算。

将各部分的结果整合起来。

由于计算机固有的整数类型存数的对大整数是2^15-1,所以为了方便,且符合中国人对长整数的表示习惯,建立一个双向循环链表,每个结点存储四位数字,以万为进制。

从最低位开始加法,超过一万向上进位,所以每次加法应该是对应两个结点和进位数相加,进位值初始为0;减法也是一个结点计算一次,每次计算应该是第一个链表对应的结点值减去第二个结点的值和借位值的和,借位值初始值为0;除法的计算可以借助减法,被减数被减数减一次则最终结果加一;直至被减数比减数小。

2.数据结构设计:需要桉顺序因为计算的是一个连续的数字,一次计算,所以采用的数据结构的逻辑结构是线性表。

因为要求每一个结点只存储四位数字,为了将数字连接起来,采用的数据结构的存储结构是链式。

课程设计 长整数四则运算

课程设计 长整数四则运算

课程设计实验报告:1.4 长整数四则运算题目:长整数四则运算一、实验内容【问题描述】设计一个实现任意长的整数进行加法运算的演示程序【基本要求】利用双向循环链表实现长整数的存储,每个结点含一个整形变量。

任何整形变量的范围是-(2^15 - 1)~(2^15 - 1)。

输入和输出形式:按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开。

【实现基本功能】(i)是想长整数的四则运算;(ii)实现长整数的乘方和阶乘运算;(iii)整形量范围是-(2^n-1)~(2^n-1),其中n是由程序读入的参量。

输入数据的分组方法另行规定;【实现加强版本的功能】(i)四则运算在原来版本的基础上支持小数运算,除法还可以通过输入整数后加小数点与相应要求取的精确位数求出精确值,如:求取3666除以7的后三位精确值,可以在输入时将除数输入为3666.000或3666.0000,就能得出相应的精确位数,当然求取后,没有余数的输出;(ii)乘方的功能也进行了强化,支持小数操作;(iii)添加了多个出错处理(即输入重操作)对相应数据输入与输出进行提示;【加强版的实现原理】(i)加减法运算加强:在原来版本的基础上依照基本的加减法操作将数据用小数点进行分隔,记录下连个输入数的小数位长度,并将小数位较短的一个数据后补0直至小数位数相同,然后用函数处理输出的数据;(ii)乘除法、乘方:其处理方法较为简单,主要是记录数据中小数位数的长度,然后通过每种运算方式不同的运算原理截取小数位,再按照输出格式将数据处理进行输出;(iii)根据定义,阶乘保持不变;【特色分析】(i)加强版程序加上了简单的声音提示,无论是输入与输出均会有八个音符的其中之一对输入与输出与否进行提示,同时在输入输出数据出错时,还会用三个音符对重输入进行提示,增强了人性化操作;【测试数据】(1)0;0;应输出“0”。

(2)-2345,6789;-7654,3211;应输出“-1,0000,0000”。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

一、需求分析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。

ston(&S,&a) 初始条件:a已存在。

操作结果:把字符串形式的长数字赋给a。

}ADT OrderedList2.本程序包含两个模块:1)主程序模块:V oid main(){选择操作:1:帮助。

2:加法。

3:减法。

4:乘法。

5:除法。

6:退出。

打印结果;}三、详细设计1.元素类型,结点类型,指针类型#define NULL 0#include<stdio.h>#include<stdlib.h>#include<conio.h>typedef struct longnode{ /*每个节点的结构*/int num; /*数字*/struct longnode *low1; /*指向低一位节点*/struct longnode *high1; /*指向高一位节点*/}longnode;typedef struct xlong{ /*每个长整数的结构*/longnode *High; /*每个长整数的最高节点*/longnode *Low; /*每个长整数的最低节点*/int digit4; /*每个长整数的总位数(不包括高位的0)/4 */ }*xlong;int init(xlong *a,int digit4){int I;/*.init.*/longnode *j;(*a)=(xlong)malloc(sizeof(struct xlong));/*为a的头结构申请空间,并赋初始值*/(*a)>High=NULL;(*a)->Low=NULL;(*a)->High=NULL; (*a)->Low=NULL;(*a)->digit4=0;for(i=0;i<digit4;i++){/* 申请digit4个节点,初始化*/j=(longnode*)malloc(sizeof(longnode));j->num=0;j->high1=NULL; j->low1=(*a)->High;if((*a)->High) (*a)->High->high1=j;else(*a)->Low=j;(*a)->High=j;(*a)->digit4++;}}int pass(xlong a,xlong b,xlong c){int cf=0; /* 两个数字的相加*/ longnode *a1=a->Low,*b1=b->Low,*c1=c->Low;while(a1){c1->num=a1->num+b1->num+cf;if(c1->num>9999){cf=1; /* 如果产生进位(借位) */c1->num-=10000;}else{cf=0;}a1=a1->high1;b1=b1->high1;c1=c1->high1;}return cf; /* 最高位的进位(借位) */}int passa(xlong a,xlong b,xlong c){int cf=0; /* 两个数字的相减*/ longnode *a1=a->Low,*b1=b->Low,*c1=c->Low;while(a1){c1->num=a1->num-b1->num-cf;if(c1->num>9999){cf=1;/* 如果产生进位(借位) */c1->num-=10000;}else{cf=0;}a1=a1->high1;b1=b1->high1;c1=c1->high1;}return cf; /* 最高位的进位(借位) */}int passb(xlong a,xlong b,xlong c){int cf=0;/* 两个数字的相乘*/longnode*a1=a->Low,*b1=b->Low,*c1=c->Low;while(a1){c1->num=a1->num*b1->num*cf;if(c1->num>9999){ cf=1; /* 如果产生进位(借位) */ c1->num=10000;}else{cf=0;}a1=a1->high1;b1=b1->high1;c1=c1->high1;}return cf; /* 最高位的进位(借位) */}int passc(xlong a,xlong b,xlong c){int cf=0;/* 两个数字的相除*/longnode *a1=a->Low,*b1=b->Low,*c1=c->Low;while(a1){ c1->num=a1->num/b1->num/cf;if(c1->num>9999){ cf=1; /* 如果产生进位(借位) */ c1->num-=10000;}else{ cf=0; }}a1=a1->high1;b1=b1->high1;c1=c1->high1; }return cf; /* 最高位的进位(借位) */}nep(xlong a){ /* 求a的相反数*/int cf=1; /* 因为求相反数是取反加一,所以这里cf=1; */ longnode *a1=a->Low;while(a1){ a1->num=9999-(a1->num)+cf;if(a1->num>9999){ a1->num=10000;}else{cf=0;}a1=a1->high1;}return;}printlong(xlong a){longnode *i=a->High;/* 打印长整数a */if(i->num>=5000){printf("-"); /* 最高位(bit)=1表示负数,即用补码表示*/ nep(a); /* 求反打印其绝对值*/} while(i&&i->num==0) i=i->low1; /* 跳过最位的0 */ if(i){printf("%d",i->num); i=i->low1;if(i) printf(“,”);}else printf(“0”); /* a=0 打0 */while(i){printf("%04d",i->num);if(i->low1)printf(",");i=i->low1; }}int ston(char in[],xlong out){ /* 把字符串转化为数字赋给a */ int bit,i,jishu=1,num0=0;longnode *j=out->Low;i=strlen(in)-1;while(i>=0 && j){ /* 循环每一个字节*/bit=in[i]-‘0’;/* 把字符形式的值赋给整数形式的bit */if(bit>=0 && bit <=9){num0+=jishu*bit; /* 加进num0 */ jishu*=10; /* 基数自乘10 */ }if(jishu>1&&(jishu>=10000||bit<0||bit>9)){ /* 数字以外的字符*/ j->num=num0;j=j->high1; /* 存入一个节点*/num0=0;jishu=1;}i--;}if(num0){j->num=num0;j=j->high1;}/* 把最后一个没存入节点的数存入节点*/for(;j;j=j->high1) j->num=0; /* 最位不足补0 */if(out->High->num>=5000)return 1; /* 如果最高位是1,返回1表示出*/if(in[0]=='-') nep(out); /* 如果最后一个字符是'-'则取反*/ return 0;}int add(){ char *a1,*b1; /*加*/int digit4,cf=0;xlong a,b,c;do{ printf("How much digits do you need?");/* 输入最多位数*/ scanf("%d",&digit4);}while(digit4<=0);a1=(char*)malloc(digit4+1);b1=(char*)malloc(digit4+1);digit4=digit4/4+1;init(&a,digit4);init(&b,digit4);init(&c,digit4); /* 初始化a,b,c */do{ cf=0; printf("Enter 2 number:\n");scanf("%s",a1);printf("+\n");scanf("%s",b1);cf|=ston(a1,a);cf|=ston(b1,b);}while(cf);/* 输入被加数和加数,如果转换出错,则重输*/ pass(a,b,c); /* 执行相加运算*/printlong(a);printf("+"); /* 打印结果*/printlong(b);printf("=");printlong(c);printf("\n");printf("\n");bioskey(0);}int subtract()/*减*/{char *a1,*b1;int digit4,cf=0;xlong a,b,c;do{printf("How much digits do you need?");/* 输入最多位*/ scanf("%d",&digit4);}while(digit4<=0);a1=(char*)malloc(digit4+1);b1=(char*)malloc(digit4+1);digit4=digit4/4+1;init(&a,digit4);init(&b,digit4);init(&c,digit4); /* 初始化a,b,c */do{ cf=0;printf("Enter2number:\n");scanf("%s",a1);printf("\n");scanf("%s",b1);cf|=ston(a1,a);cf|=ston(b1,b);}while(cf); /* 输入被减数和减数,如果转换出错,则重输*/ passa(a,b,c); /* 执行相减运算*/printlong(a);printf("-"); /* 打印结果*/printlong(b);printf("=");printlong(c);printf("\n");printf("\n");bioskey(0);}int multiply() /*乘*/{ char *a1,*b1;int digit4,cf=0;xlong a,b,c;do{ printf("How much digits do you need?"); /* 输入最多位数*/ scanf("%d",&digit4);}while(digit4<=0);a1=(char*)malloc(digit4+1); b1=(char*)malloc(digit4+1);digit4=digit4/4+1;init(&a,digit4);init(&b,digit4);init(&c,digit4); /* 初始化a,b,c */do{ cf=0;printf("Enter2number:\n");scanf("%s",a1);printf("*\n");scanf("%s",b1);cf|=ston(a1,a);cf|=ston(b1,b);}while(cf);/* 输入被乘数和乘数,如果转换出错,则重输*/ passb(a,b,c); /* 执行相乘运算*/printlong(a);printf(“*”);/* 打印结果*/printlong(b);printf("=");printlong(c);printf("\n");printf("\n");bioskey(0);}int division() /*除*/{ char *a1,*b1;int digit4,cf=0;xlong a,b,c;do{ printf("How much digits do you need?"); /*输入最多位数*/ scanf("%d",&digit4);}while(digit4<=0);a1=(char*)malloc(digit4+1);b1=(char*)malloc(digit4+1);digit4=digit4/4+1;init(&a,digit4);init(&b,digit4);init(&c,digit4); /* 初始化a,b,c */do{ cf=0;printf("Enter 2 number:\n");scanf("%s",a1);printf("/\n");scanf("%s",b1);cf|=ston(a1,a);cf|=ston(b1,b);}while(cf); /* 输入被除数和除数,如果转换出错,则重输*/ passc(a,b,c); /* 执行相除运算*/printlong(a);printf("/"); /* 打印结果*/printlong(b);printf("=");printlong(c);printf("\n");printf("\n");bioskey(0);}2.主函数代码void main() /*main*/{ int c;clrscr();textcolor(BLUE);printf("***********************************************\n");printf("*********Welcome to Thunder studio!************\n"); printf("***********************************************\n"); printf("*********本程序实现长整数四则运算**************\n"); one: printf("1: ------HELP\n");printf("2: ------ADD\n");printf("3: ------SUBTRACT\n");printf("4: ------MULTIPLY\n");printf("5: ------DiVISION\n");printf("6: ------EXIT\n");for(;;){c=getch();switch(atoi(&c)){case 1: clrscr(); goto one; break;case 2: add(); break;case 3: subtract(); break;case 4: multiply(); break;case 5: division(); break;case 6: textcolor(BLUE);printf("\n------------------------------------------------------------\n");printf("Thanks cw's work!!\n");break;default: textcolor(4);printf("Sorry please input right number!\n");break;}}}四、调试分析1.由于对基本要求看得不仔细,一开始使用的形式是数组,并非链表,导致空间开销大.2.本程序的模块划分比较合理,且尽可能将指针的操作封装在结构体中,对于一个长整数只需一个指针便可访问其所有信息,所以数据结构清晰.3.算法的时空分析1)本程序的计算量不是很大,所以时间复杂度极低.2)每个长整数的位数可能不同,考虑到根据位数调整空间比较麻烦,而且容易出错,所以对每个长整数都是用同样大小的空间储存的.3)由于计算完毕,显示结果后程序即结束,所以无须释放空间.五、用户手册1.本程序的运行环境为DOS操作系统,执行文件为:j01242_5.EXE。

相关文档
最新文档