任意长整数的乘法数据结构课程设计报告样本
数据结构课程设计长整数四则运算
数据结构课程设计题目：长整数四则运算班级学号学生姓名提交日期成绩计算机与通信工程学院长整数四则运算一需求分析：问题描述：设计一个实现任意长的整数进行加法运算的演示程序。
基本要求：利用双向循环链表实现长整数的存储，每个结点含一个整形变量。
任何整形变量的范围是 -(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)//将各个位的正负、大小、进位进行调整源程序：。
长整数运算实验报告
一、实验目的1. 理解长整数的概念及其在编程中的应用。
2. 掌握长整数的基本运算方法，包括加法、减法、乘法和除法。
3. 提高编程能力，通过实际操作加深对长整数运算的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 长整数的定义与初始化2. 长整数的加法运算3. 长整数的减法运算4. 长整数的乘法运算5. 长整数的除法运算四、实验步骤1. 长整数的定义与初始化在Python中，长整数不需要特殊声明，只需按照常规整数进行定义即可。
下面是长整数的定义与初始化示例：```pythona = 123456789012345678901234567890b = 987654321098765432109876543210```2. 长整数的加法运算长整数的加法运算与常规整数相同，使用`+`符号。
下面是长整数加法运算的示例：```pythonresult = a + bprint("加法运算结果：", result)```3. 长整数的减法运算长整数的减法运算同样与常规整数相同，使用`-`符号。
下面是长整数减法运算的示例：```pythonresult = a - bprint("减法运算结果：", result)```4. 长整数的乘法运算长整数的乘法运算与常规整数相同，使用``符号。
下面是长整数乘法运算的示例：```pythonresult = a bprint("乘法运算结果：", result)```5. 长整数的除法运算长整数的除法运算与常规整数相同，使用`/`符号。
下面是长整数除法运算的示例：```pythonresult = a / bprint("除法运算结果：", result)```五、实验结果与分析1. 长整数的定义与初始化：通过定义长整数，我们了解了长整数在Python中的表示方法。
超长正整数加法和乘法报告书
信息工程学院数据结构与C语言综合训练报告（2011～2012学年第二学期）报告题目：____超长正整数的加法________姓名：______李莉_______专业：信息管理与信息系统年级班级： ____112班________指导教师：__李宏利、张晶___完成日期：_2012年7月12日一、综合训练目的和要求本综合训练是计算机科学与技术、信息管理与信息系统、软件工程、电子商务专业重要的实践性环节之一，是在学生学习完《程序设计语言(C)》、《数据结构》课程后进行的一次全面的综合练习。
本课综合训练的目的和任务：1. 巩固和加深学生对C语言、数据结构课程的基本知识的理解和掌握2. 掌握C语言编程和程序调试的基本技能3. 利用C语言进行基本的软件设计4. 掌握书写程序设计说明文档的能力5. 提高运用C语言、数据结构解决实际问题的能力二、综合训练任务内容利用双向循环链表，设计一个实现任意长的整数进行加法运算的演示程序。
要求输入和输出每四位一组，组间用逗号隔开。
如：1，0000，0000，0000，0000。
提高要求：完成两个超长正整数的乘法。
三、总体设计函数调用关系图（如下）mainAdd() Output() Input() Change() Mul()Sum()函数的流程图（如下）Y NYNNY开始m=0操作说明 输入字符串a[] Input() n=N输入n 输入字符串b[] Input() n=N ’输入n Change(a) Change(b) 输入mMul()Add()四、详细设计说明主函数模块包括判断函数输入模式是否正确的模块，输入转换模块，数值计算模块和输出模块。
在主函数中首先调用函数Input （），然后调用到函数Change （），在Change （）函数中调用了函数Sum （），随后主函数中又根据操作者调用了函数Add （）或者函数Mul （），最后主函数调用了函数Output （）后程序结束。
长整数四则运算 实验报告
“数据结构”课程设计报告长整数四则运算学生姓名：吴成杰徐文良指导教师：陈少军所在系：电子信息系所学专业：计算机科学与技术年级：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组员分配任务我们组有两个成员，分别为吴成杰和徐文良，一个负责写主函数、函数整体的框架和写转换函数函数和对输入的字符进行处理，一个负责写出栈函数和写处理函数和拼接，程序出现错误，两个人一起在一起互相商量，修改。
长整数的代数计算----数据结构课程设计
沈阳航空航天大学课程设计报告课程设计名称：数据结构课程设计课程设计题目：长整数的代数计算院（系）：计算机学院专业：计算机科学与技术班级：学号：姓名：指导教师：沈阳航空航天大学课程设计报告目录1 题目介绍和功能要求 (1)1.1题目介绍 (1)1.2功能要求 (1)1.3基本功能 (1)2 系统功能模块结构图 (2)2.1系统功能结构框图 (2)2.2系统主要模块的功能说明 (2)3 使用的数据结构的描述 (4)3.1数据结构设计 (4)3.2数据结构用法说明 (4)4 函数的描述 (5)4.1主要函数设计 (5)4.2主要函数流程图 (6)5程序测试和运行的结果 (11)5.1程序测试 (11)5.2运行结果 (12)6参考文献 (14)附录（关键部分程序清单） (15)沈阳航空航天大学课程设计报告1 题目介绍和功能要求1.1 题目介绍设计数据结构完成长整数的表示和存储，并编写算法来实现两个长整数的加、减、乘、除等基本代数运算。
1.2 功能要求1) 长整数长度在一百位以上。
2）实现两长整数在同余代数下的加、减、乘、除操作。
即实现算法来求解a+b mod n，a-b mod n，a*b mod n，a\b mod n。
3）输入输出均在文件中。
（选作）1.3 基本功能1.jiafa();将一百位以上的长整数进行加法运算，计算出和。
2.jianfa();将一百位以上的长整数进行减法运算，计算出差。
3.chenfa();将一百位以上的长整数进行乘法运算，计算出积。
4.chufa();将一百位以上的长整数进行除法运算，计算出商和余数。
2 系统功能模块结构图2.1 系统功能结构框图图2.1 系统功能结构框图2.2 系统主要模块的功能说明1.主模块kongzhi()；控制输入模块、加法模块、减法模块、乘法模块、除法模块、输出模块的循环使用。
2.输入模块shuru();将输入的两组长整数分别通过转换将其转换成所需要的形式存储到两个链表（opr1、opr2）中保存起来。
长整数四则运算+数据结构课程设计
长整数四则运算+数据结构课程设计长整数四则运算题目：编制一个演示长整数的四则运算的程序一、需求分析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.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”。
数据结构课程设计报告长整数运算范文
数据结构课程设计报告长整数运算数据结构课程设计报告题目：长整数四则运算一、需求分析1.问题描述：由于工程上有时候需要对很大的数进行计算，可是计算机本身提供的数据类型无法保存几百位甚至几千位的数字，因此需要设计专门的算法对数据进行相应的计算。
此程序的设计任务是：设计一个程序能够实现长整数运算的程序，而且能够对一些错误异常进行辨别调整，计算出正确的结果。
程序输入格式是字符串，保存时需要用双向循环链表将字符串每四位保存在循环链表中的一个节点中，然后再计算后运行出结果。
2.基本功能功能一：建立双向循环链表,计算链表个数，对链表的数据进行修改，能在链表中插入结点。
功能二：将字符串转换成相应的数字存储在双向循环链表中功能三：对存入双向循环链表的长整数进行相加，相减，相除。
3.输入输出程序输入以字符串的形式输入，数据的类型是字符串，包含元素的范围是数字，逗号，负号。
输入时用字符串输入，输出时以一链表结点输出，而且每个结点表示四位。
二、概要设计1.设计思路：由于计算机无法完成位数很大的数字计算，设计思路就是将很长的数据进行分割，一部分一部分的用计算机固有数据类型进行计算。
将各部分的结果整合起来。
由于计算机固有的整数类型存数的对大整数是2＾15-1，因此为了方便，且符合中国人对长整数的表示习惯，建立一个双向循环链表，每个结点存储四位数字，以万为进制。
从最低位开始加法，超过一万向上进位，因此每次加法应该是对应两个结点和进位数相加，进位值初始为0；减法也是一个结点计算一次，每次计算应该是第一个链表对应的结点值减去第二个结点的值和借位值的和，借位值初始值为0；除法的计算能够借助减法，被减数被减数减一次则最终结果加一；直至被减数比减数小。
2.数据结构设计：因为计算的是一个连续的数字，需要桉顺序一次计算，因此采用的数据结构的逻辑结构是线性表。
因为要求每一个结点只存储四位数字，为了将数字连接起来，采用的数据结构的存储结构是链式。
《数据结构》课程设计报告-任意长的整数加减法运算
中国石油大学（北京）远程教育学院《数据结构》课程设计报告2019 ～2019 学年第 1 学期课程设计题目第一题任意长的整数加减法运算2019 年8 月任意长的整数加减法运算1需求分析设计算法，实现一个任意长的整数进行加法、减法运算的演示程序。
例如：1234，5123，4512，3451，2345与-1111，1111，1111，1111，1111的加法结果为：0123，4012，3401，2340，1234。
基本要求如下：（1）利用链表实现长整数的存储，每个节点含一个整型变量；（2）整型变量的范围：-（2^15 -1）~（2^15 -1）；（3）输入与输出形式每四位一组，组间用逗号分隔开。
如：1986,8213,1935,2736,3299；（4）界面友好，每步给出适当的操作提示，并且系统具有一定的容错能力。
至少给出下面的测试数据：（1）0；0（2）-2345,6789；-7654,3211（3）-9999,9999；1,0000,0000,0000（4）1,0001,0001；-1,0001,0001（5）1,0001,0001；-1,0001,0000（6）-9999,9999,9999；-9999,9999,9999（7）1,0000,9999,9999； 12概要设计注意这里是整数，浮点数需要额外的操作，实现大整数的加减，三个栈就OK了，两个运算整数栈，一个结果栈，基本的逻辑的就是利用栈的先入后出的特点将高位push到栈底，低位push到栈顶，之后两个栈pop出来之后push到结果栈，结果栈pop出来就是我们想要的结果。
typedef char ElemType;typedef struct{ElemType *base;ElemType *top;int stacksize;}sqStack;void initStack(sqStack *s)void Push(sqStack *s, ElemType e)void Pop(sqStack *s , ElemType *e)int StackLen(sqStack s)void ADD(sqStack *s1,sqStack *s2,sqStack *s3)3详细设计1. 主函数设计int main(){char e;sqStack s1,s2,s3;initStack(&s1); /*初始化堆栈s1，存放加数*/initStack(&s2); /*初始化堆栈s2，存放加数*/initStack(&s3); /*初始化堆栈s3，存放结果*/printf("江紫花090451\n"); /*输入第一个任意长整数，按”#”结尾*/printf("Please input the first integer\n"); /*输入第一个任意长整数，按”#”结尾*/scanf("%c",&e);while(e!='#'){Push(&s1,e); /*将加数（字符串）入栈s1*/scanf("%c",&e);}getchar(); /*接收回车符*/printf("Please input the second integer\n"); /*输入第二个任意长整数，按”#”结尾*/scanf("%c",&e);while(e!='#'){Push(&s2,e); /*将加数（字符串）入栈s2*/scanf("%c",&e);}ADD(&s1,&s2,&s3); /*加法运算，将结果存放在s3中*/printf("The result is\n");while(StackLen(s3)!=0) /*输出结果，打印在屏幕上*/{Pop(&s3,&e);printf("%c",e);}void initStack(sqStack *s){/*内存中开辟一段连续空间作为栈空间，首地址赋值给s->base*/s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));if(!s->base) exit(0); /*分配空间失败*/s->top = s->base; /*最开始，栈顶就是栈底*/s->stacksize = STACK_INIT_SIZE; /*最大容量为STACK_INIT_SIZE */ }/*入栈操作，将e压入栈中*/void Push(sqStack *s, ElemType e){if(s->top - s->base >= s->stacksize){/*栈满，追加空间*/s->base = (ElemType *)realloc(s->base, (s->stacksize +STACKINCREMENT)*sizeof(ElemType));if(!s->base) exit(0); /*存储分配失败*/s->top = s->base + s->stacksize;s->stacksize = s->stacksize + STACKINCREMENT; /*设置栈的最大容量*/}*(s->top) = e; /*放入数据*/s->top++;}/*出栈操作，用e将栈顶元素返回*/void Pop(sqStack *s , ElemType *e){if(s->top == s->base) return;*e = *--(s->top);}/*计算堆栈s当前的长度*/int StackLen(sqStack s){return (s.top - s.base) ;}void ADD(sqStack *s1,sqStack *s2,sqStack *s3){char a1,a2,a3,c=0; /*a1,a2分别存放从堆栈s1,s2中取出的（数据）元素，a3=a1+a2,c中存放进位*/while(StackLen(*s1)!=0 && StackLen(*s2)!=0){Pop(s1,&a1); /*取出s1栈的栈顶元素给a1*/Pop(s2,&a2); /*取出s2栈的栈顶元素给a2*/a3 = (a1-48) + (a2-48) + c + 48; /*相加*/if(a3>'9'){a3 = a3 - '9' + 47; /*产生进位的情况*/c = 1;}elsec = 0; /*不产生进位*/Push(s3,a3); /*将结果入栈s3*/}if(StackLen(*s1)!=0) /*栈s1不为空的情况*/{while(StackLen(*s1)!=0){Pop(s1,&a1); /*取出s1栈的栈顶元素给a1*/a3 = a1 + c ; /*与进位标志c相加*/if(a3>'9'){a3 = a3 - '9' + 47; /*产生进位的情况*/c = 1;}elsec = 0; /*不产生进位*/Push(s3,a3); /*将结果入栈s3*/}}else if(StackLen(*s2)!=0) /*栈s1不为空的情况*/{while(StackLen(*s2)!=0){Pop(s2,&a2); /*取出s1栈的栈顶元素给a1*/a3 = a2 + c; /*与进位标志c相加*/if(a3>'9'){a3 = a3 - '9' + 47; /*产生进位的情况*/c = 1;}elsec = 0; /*不产生进位*/Push(s3,a3); /*栈s1不为空的情况*/}}if(c==1)Push(s3,'1'); /*如果最后有进位，将字符’1’入栈s3*/ }4程序测试（1）0；0（2）-2345,6789；-7654,3211（3）-9999,9999；1,0000,0000,0000（4）1,0001,0001；-1,0001,0001（5）1,0001,0001；-1,0001,0000（6）-9999,9999,9999；-9999,9999,9999（7）1,0000,9999,9999； 15感想与体会这是一门纯属于设计的科目，它需用把理论变为上机调试。
大整数乘法实验报告
大整数乘法实验报告实验报告--大整数实验报告题目：班级：计算机092班姓名：徐丽莉学号：09136218 完成日期：2010.11.13目的与要求：1、线性表的链式存储结构及其基本运算、实现方法和技术的训练。
2、单链表的简单应用训练3、熟悉标准模版库STL中的链表相关的知识需求分析1、编程实现单链表的基本操作2、利用单链表存储大整数（大整数的位数不限）3、利用单链表实现两个大整数的相加、相减运算（减法运算可选做）4、进行测试。
5、用STL之list完成上面的任务。
6、尝试完成HLoj 1020。
输入：12312312341234输出：2462468概要设计抽象数据类型线性表的定义如下：ADT List {数据对象：D＝{ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 }{称n 为线性表的表长; 称n=0 时的线性表为空表。
}数据关系：R1＝{ ai-1 ,ai |ai-1 ,ai∈D, i=2,...,n }{设线性表为(a1，a2, . . . ，ai，. . . ，an), 称i 为ai 在线性表中的位序。
} 基本操作：} ADT ListLinkList{LNode *head;// 头指针(带头结点)LNode *tail , *cur; // 尾指针, 当前指针//intlength;// 链表长度bool Init(); // 初始化初始条件：无操作结果：初始化void Clear();初始条件：已存在操作结果：// 清除单链表void Create(int n);初始条件：无操作结果：// 建立含n个结点的单链表 int Locate(int e); // 查找初始条件：已存在操作结果：// 清除线性表void InsertBefore(int i, int e);// 插入元素初始条件：已存在操作结果：// 清除线性表bool Delete(int i,int &e);// 删除元素初始条件：已存在操作结果：// 清除线性表void Traverse();初始条件：已存在操作结果：// 遍历，并输出内容bool Empty();初始条件：已存在操作结果：// 判断空表bool GetElem(int i,int &e);初始条件：已存在操作结果：//获取元素void createlistbyorder(string s);初始条件：无操作结果：//字符串创建链表}; LinkList2、主程序的处理流程int main(){线性表LA,LB,LC初始化；读入2个字符串；将这2个字符串创建成链表；分别用2个指针指向线性表表头；进行运算；遍历被插入的链表LC（即输出运算结果）；return 0; }三、详细设计1、线性表的实现struct LinkList{LNode *head;// 头指针(带头结点)LNode *tail , *cur; // 尾指针, 当前指针//intlength;// 链表长度bool Init();// 初始化void Clear(); // 清除线性表void Create(int n);// 建立含n个结点的单链表int Locate(int e); // 查找void InsertBefore(int i, int e);// 插入元素bool Delete(int i,int &e);// 删除元素void Traverse();// 遍历，并输出内容bool Empty(); // 判断空表 bool GetElem(int i,int &e);//获取元素void createlistbyorder(string s); //字符串创建链表};bool LinkList::Init( ){head=new LNode;head-next=NULL;return true;}void LinkList::InsertBefore(int i, int e){LNode *p=head;while (p-next!=NULL && i1){p=p-next;i--;}if (p==NULL || i 1) return;LNode *s=new LNode;s-data = e;s-next = p-next;p-next = s;}bool LinkList::Delete (int i, int &e){LNode *p=head;int j=0;while (p-next!=NULL && j i-1){p = p-next;++j;}// 寻找第i 个结点，并令p 指向其前趋if (!(p-next) || j i-1) return false; // 删除位置不合理LNode *q = p-next;p-next = q-next; // 删除并释放结点e = q-data;delete q;return true;void LinkList::Clear(){LNode *p;while (head-next!=NULL){p=head-next;head-next=p-next;}}int LinkList::Locate(int e){LNode *p=head-next;int j=0;while(p!=NULL&&p-data!=e) {j++;p=p-next;}return j;}void LinkList::Create(int n)head = new LNode;head-next =NULL; // 先建立一个带头结点的单链表for (int i = n; i 0; -{LNode *p = new LNode;cinp-data; // 输入元素值p-next = head-next;head-next = p; // 插入}}void LinkList::Traverse(){LNode *p=head-next;while(p!=NULL){coutp-dataendl;p=p-next;}}bool LinkList::Empty(){if(head-next=NULL) return true; else return false;}bool LinkList::GetElem(int i,int &e)//获取元素{if(i1 ) return false;LNode *p=head-next;while(p!=NULL && i1){i--;p=p-next;}if(p==NULL) return false;else e=p-data;return true;}void LinkList::createlistbyorder(string s) {for(int i=0;is.size();i++){LNode *p=head;篇二：JAVA实验报告处理大整数实验4 处理大整数1.相关知识点程序有时需要处理大整数，java.math包中的BigInteger类提供任意精度的整数运算。
数据结构课程设计报告大数相乘与多项式相乘
数据结构课程设计报告大数相乘与多项式相乘一、引言数据结构是计算机科学中非常重要的一门课程，它涉及到数据的存储、组织和处理方法。
在本次课程设计报告中，我们将重点讨论大数相乘和多项式相乘两个问题，并给出相应的解决方案。
二、大数相乘1. 问题描述大数相乘是指两个超过计算机所能表示范围的整数相乘的问题。
在实际应用中，大数相乘时常浮现在密码学、数值计算和科学计算等领域。
2. 解决方案为了解决大数相乘的问题，我们可以采用分治算法。
具体步骤如下：- 将两个大数分别划分为高位和低位部份，例如将大数A划分为A1和A0，将大数B划分为B1和B0。
- 分别计算A1 * B1、A0 * B0和(A1 + A0) * (B1 + B0)的结果。
- 将上述三个结果通过适当的位移和加法运算得到最终的结果。
3. 算法实现下面是使用分治算法实现大数相乘的伪代码：```function multiply(A, B):if A 或者 B 是小数:直接返回 A * Belse:将 A 和 B 分别划分为高位和低位部份A1, A0 = 高位部份B1, B0 = 低位部份X = multiply(A1, B1)Y = multiply(A0, B0)Z = multiply(A1 + A0, B1 + B0)结果 = (X << n) + ((Z - X - Y) << n/2) + Y返回结果```4. 实例分析以A = 123456789 和 B = 987654321为例，我们可以通过上述算法得到它们的乘积为 121932631137021795。
三、多项式相乘1. 问题描述多项式相乘是指两个多项式相乘的问题。
在实际应用中，多项式相乘时常浮现在信号处理、图象处理和机器学习等领域。
2. 解决方案为了解决多项式相乘的问题，我们可以采用传统的乘法算法。
具体步骤如下：- 将两个多项式分别表示为系数和指数的形式，例如多项式A可以表示为A =a0x^0 + a1x^1 + ... + anx^n。
数据结构：长整数的加减法(任意长度的加减法)
《数据结构》课程设计报告课程设计报告名称长整数的加法运算实验室实验楼502 完成日期 2018年11月30日}(2) 程序结构图(3) 功能模块3. 详细设计：1. 存储结构采用双向链表，使用头结点存放符号，后继节点存放其数字部分长整数的运算计算方式加法减法结果输入符号位数字部分输入两个长整数选择计算方式 加法模块 减法模块3.算法描述1.针对同号加法void Sub(DualList a, DualList b, DualList c)对两个链表的节点进行的最低位进行加法，默认都需要进位，超过10000的情况，会给在操作下一位的时候在加上进位数字1，如果没有发生进位那就加上进位数0void Add(DualList a, DualList b, DualList c){DualList pa, pb;int carry = 0, tmp;pa = a->prior;pb = b->prior;while((pa != a) && (pb != b)){tmp = pa->data + pb->data + carry;if (tmp >= 10000){carry = 1;tmp -= 10000;}elsecarry = 0;InsertNodeAtHead(c, tmp);pa = pa->prior;pb = pb->prior;}while(pa != a){// pb = btmp = pa->data + carry;if (tmp >= 1000){carry = 1;tmp -= 10000;}elsecarry = 0;InsertNodeAtHead(c, tmp);pa = pa->prior;}while(pb != b){// pa = atmp = pb->data + carry;if (tmp >= 1000)4. 调试分析：错误分析：.经常出现忘记符号终止符号，或大小写的小问题导致编译无法通过不安全的设计导致计算机崩溃(无图) 最后结果显示错误1.第一数字输入InputData()2.第2数字输入InputData()输入符号InitList()加入数字InsertNodeAtHead( L,data)加法DualList AddList( a, b)加减法选择同号Add()同号Sub()减法DualList SubList( a, b)结果PrintList(DualList L)正确测试结果：三、设计总结通这次实验让我充分认识到了自己所掌握程序设计知识的贫瘠，在长整的数字的运算之中，在一些数字的长度人可以接受的范围内我们通过用笔列算式、大脑的思考对两个较长的整数进行运算如果计算能力可以的话很快就能得出结果，整个运算的过程简单。
数据结构课程设计长整数运算-参考模板
一、需求分析【问题描述】设计一个程序实现两个任意长的整数求和运算。
【基本要求】利用双向循环链表实现长整数的存储，每个结点含一个整型变量。
任何整型变量的范围是：-（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）输入两个数，用链表来存储。
长整数的运算算法与数据结构课程设计报告书
*******************实践教学*******************兰州理工大学软件学院2013年春季学期算法与数据结构课程设计题目：长整数的运算专业班级：软件二班姓名：齐祥荣学号：12700244指导教师：王连相成绩：目录摘要 (1)前言 (2)正文 (3)1.采用类C语言定义相关的数据类型 (3)2.各模块的伪码算法 (3)3.函数的调用关系图 (7)4.调试分析 (8)5.测试结果 (8)6.源程序（带注释） (9)总结 (19)参考文献 (20)致谢 (21)附件Ⅰ部分源程序代码 (22)摘要数据结构该设计要求学生设计程序，实现两个任意长的整数求和及差的运算问题。
通过该题目的设计过程，可以加深理解线性表的逻辑结构、存储结构，掌握线性表上基本运算的实现，进一步理解和熟练掌握课本中所学的各种数据结构，学会如何把学到的知识用于解决实际问题，培养学生的动手能力关键词：双循环链表；插入；删除；长整数加减前言利用双向循环链表来实现对长整数的存储。
每个节点只存储四位十进制数字，即不超过9999的非负整数。
双向链表有头指针，它的data值存储长整数的符号，1为正，-1为负，0代表长整数为0；它的over值存储除头节点外节点的个数。
其他节点的data值存储四位整数，over存储该四位整数溢出0~~9999范围的情况，一般over>0表示四位数超出9999，over<0表示四位数小于0。
选择该数据结构来完成长整数的加减运算是因为要对长整数进行运算，需要对长整数进行存储，所以选择用链表对长整数存储，又由于存储的顺序是从左到右，而运算的顺序则是从右到左，这样位了操作方便选择循环链表，在运算过程中有进位和借位的操作，所以最终选择双向循环链表的数据结构。
正文1.采用类c语言定义相关的数据类型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() //入口函数2.各模块的伪码算法1.宏定义及链表定义：#define N 100typedef int DataType;typedef struct DoubleNode //定义链表元素{ DataType data;struct DoubleNode *prior;struct DoubleNode *next; }DLNode;void InitNode(DLNode **head) //初始化链表{每个节点只存储四位十进制数字，即不超过9999的非负整数。
课程设计 长整数四则运算
课程设计实验报告：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”。
整数乘法的教学设计范文（精选3篇）
整数乘法的教学设计范文（精选3篇）整数乘法的教学设计范文（精选3篇）作为一位不辞辛劳的人民教师，通常需要准备好一份教学设计，借助教学设计可以更大幅度地提高学生各方面的能力，从而使学生获得良好的发展。
写教学设计需要注意哪些格式呢？下面是小编整理的整数乘法的教学设计范文（精选3篇），仅供参考，欢迎大家阅读。
整数乘法的教学设计1教学要求：1、使学生进一步掌握乘法和除法的意义，掌握乘除之间的关系，数学教案－整数的乘法和除法。
使学生受到辩证唯物主义的启蒙教育。
掌握乘除法算式中各部分间的关系，并能应用这些关系求未知数x，初步学会用x表示要求的数，列出含有未知数x的等式，解答一步计算的乘除法应用题。
2、使学生理解并掌握乘法的交换律，结合律，分配律，并能运用这些运算定律进行一些简便计算，并为进一步学习数学打下基础。
教学重点：1、理解乘法和除法的意义，掌握乘除法各部分间的关系，会求未知数x。
2、理解乘法的交换律，分配律，结合律，能够运用定律简算。
[第1课时]教学时间：教学内容：乘除法的意义课型：新授课教学目的：1、使学生进一步理解乘、除法的意义，并能够运用它解决实际问题。
2、通过以定义的形式概括出乘、除法的确切意义，培养学生的思维深刻性。
3、使学生学会在感性材料的基础上，抓住事物的内在联系来认识事物的规律性。
教学重点：理解乘、除法的意义。
教具准备：投影片教学过程：一、引入：1、谈话：今天我们在过去学的知识的基础上进行概括总结，学习乘除法的意义。
板书课题：乘除法的意义2、口算练习：5×7= 6×8=35÷5= 48÷6=35÷7= 48÷8=二、新授：1、（投影）例：（1）一年级有3个班，每班有40人，一共有多少人？提问：你能用几种方法解答？哪两种？用加法算：40+40+40=120（人）用乘法算：40×3=120（人）提问：40×3=120这个算式表示什么？引导提问：（1）比较两个算式，哪个算式比较简便？（2）想一想，乘法是一种什么样的运算？（简便运算）（3）乘法是一种求什么的简便运算？板书：乘法是求几个相同加数和的简便运算。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计说明书 NO.1
任意长整数的乘法
1、课程设计目的
( 1) 较熟练地掌握数据结构( C语言) 课程的基本内容, 程序设计的基本方法与编程技巧。
( 2) 较熟练地掌握C语言程序编辑、编译、连接和运行的方法。
( 3) 经过运行C程序, 了解C语言的特点, 培养学生应用计算机解决和处理实际问题的思维方法与基本能力。
2、课程设计方案论证
2.1 设计思路
( 1) 输入的形式和输入值的范围:
用户从键盘输入2个任意长度的长整数, 输入的时候是按4个为一段输入的, 即一段一段输入的, 求它们的乘积的大小, 并将结果在屏幕上显示; 2个长整数的输入没有大小的限制, 要输入多大的数据,就能够输入多大的数据。
( 2) 输出的形式:
输出直接在屏幕上显示2个任意长度的长整数的乘积大小。
( 3) 程序所能达到的功能:
对于用户输入的任意长度的2个的长整数, 能够正确没有错误的显示结果, 和电脑附件中的计算器的计算值要一致; 能够准确无误地显示结果。
( 4) 测试数据:
如输入1000 1000 和1111 2个长整数后, 显示0111 1111 1111 1000的话, 就是正确的结果形式。
如输入1111 1111 1111和1111 2个长整数后, 结果显示0123 4444 4444 4322就不是正确结果, 因为这2个长整数的积为0123 4444 4444 4321
2.2概要设计
( 1) 抽象数据类型的定义
为了实现任意长整数的乘法, 因为这种运算存在进位和位移等操作, 因此选择双链表的结构体( 如图2.2.1和图2.2.2) , 它有一个data, left, right; 考虑到data表示的数据的范围, 使它只接受4个数字的整数, 这样一个长整数就分为若干段, 每一段为4个数
沈阳大
学
课程设计说明书 NO2
字, 便于进位和借位以及位移的操作, 用户在输入时就是每次输入4个数字。
( 2) 主程序的流程
主程序是首先调用初始化2个长整数的函数, 用户4个数字一段一段地输入2个长整数, 用双链表的形式和头插法的形式建立, 返回2个长整数的头节点; 建立完2个长整数后,就开始进行2个长整数的乘积的运算了;
首先将第一个长整数的全部去乘第2个长整数的最后一段, 这样得到一个长整数; 接着将第一个长整数的全部去乘第2个长整数的倒数第2段; 这样得到一个长整数, 可是要向左位移4位; 这次得到的长整数要和上一次相加, 得到一个新的长整数; 接着接着将第一个长整数的全部去乘第2个长整数的倒数第3段, 得到一个长整数, 再和前面相加;
依次进行, 一直到已经到第一个长整数的全部乘于了第2个长整数的最高1段, 那么乘法就结束了; 这时将得到的长整数从高位到低位一段一段, 4个4个数字显示在屏幕上, 程序就运行结束了。
( 3) 模块之间的层次(调用)关系
程序的调用关系如下: 主函数调用了初始化2个长整数的函数, 然后再调用了2个2个长整数的乘积的函数; 2个长整数的乘积的函数调用了部分求和的函数和从表头得到表尾的函数, 以及将一个长整数前后数值交换的函数以及显示一个长整数的函数。
图1双链表的数据结构
图2双链表的数据结构( 虚线部分为地址值, 这个是为了描述方便随便写的值)
沈阳大学
课程设计说明书 NO.3
2.3详细设计
( 1) 2个长整数的输入
接着采用头插法的方式, 当输入一个4个数字的整数时, 就产生一个新的节点, 它的值为输入的整数值, 建立起它的左右指针, 并用头节点指向它; 为了判断一个长整数是否输入结束, 定义一个结束标志, 当输入正数时就继续, 当输入负数时, 就结束一个长整数的输入; 同时用一个函数得到长整数的尾节点和段数, 段数在比较2个数的大小有用。
( 2) 2个长整数的乘法
先定义一个部分加法的函数, 就是2个正的长整数的加法的运算; 它从2个长整数的尾部开始, 同时相加, 接着再向左移一段, 又同时相加; 当2个数据的某一段同时存在时, 就相加; 当一个数据已经全部被相加后, 另外一个数据的剩下的段就要全部复制到和中; 在实行加法的时候, 设置一个进位标志位, 目的是为了使结果正确; 当一段的数据相加产生进位时, 那么进位标志位为1; 下一次一段的数据相加就要加上这个进位标志位; 而且如果2个长整数的所有的段的数据都相加完了, 还要判断是否产生了进位标志位, 如果有的话, 就要新建一个节点, 它的值就是1; 2个正的长整数的求和就完成了。
再定义一个部分乘法的函数, 就是1个正的长整数乘于一个4位整数, 并向左位移特定的段数的运算; 其实开始实现向左位移的运算, 只需要建立新的节点, 节点的数目为需要左移段数, 并将这些节点的值设置为0; 接着实现一个长整数乘于一个4位整数的运算, 采用每一段都和这个4位整数的相乘的方法, 当积超过10000时, 那么多于高4位全为进位, 参与下一次相乘时要加上它; 低4位就是要新建的节点的值; 和加法一样, 当这个正的长整数的每一段都和这个4位整数相乘后, 但还存在进位时, 就要新建一个节点, 它的值就是进位值; 现在1个正的长整数乘于一个4位整数, 并向左位移特定的段数的运算就完成了;
再实现2个正的长整数的乘法的运算, 采用第一个长整数作为一个整体乘于第二个长整数的每一段, 并向左位移的方法; 例如当采用第一个长整数作为一个整体乘于第二个长整数的最后一段, 就不用向左位移; 可是第一个长整数作为一个整体乘于第二个
沈阳大学
课程设计说明书 NO.4。