大整数的乘法实验报告
整数工程实验报告模板
一、实验目的1. 理解整数运算的基本原理和方法。
2. 掌握整数加、减、乘、除运算的算法实现。
3. 通过编程实践，提高算法设计和编程能力。
4. 熟悉整数运算在工程应用中的重要性。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 20194. 实验设备：个人电脑三、实验原理整数运算是指对整数进行加、减、乘、除等基本数学运算。
在计算机科学中，整数运算的实现通常基于二进制表示和位操作。
本实验将基于此原理，通过编程实现整数运算。
四、实验内容1. 实现整数加法算法。
2. 实现整数减法算法。
3. 实现整数乘法算法。
4. 实现整数除法算法。
5. 编写测试程序，验证算法的正确性。
五、实验步骤1. 整数加法算法实现- 定义一个函数，接受两个整数参数，返回它们的和。
- 使用位操作实现加法运算。
2. 整数减法算法实现- 定义一个函数，接受两个整数参数，返回它们的差。
- 使用位操作实现减法运算。
3. 整数乘法算法实现- 定义一个函数，接受两个整数参数，返回它们的乘积。
- 使用位操作和位移操作实现乘法运算。
4. 整数除法算法实现- 定义一个函数，接受两个整数参数，返回它们的商和余数。
- 使用位操作和位移操作实现除法运算。
5. 编写测试程序- 编写测试函数，用于验证加、减、乘、除算法的正确性。
- 测试不同大小的整数，包括正数、负数和零。
六、实验结果与分析1. 整数加法- 输入：5，3- 输出：8- 分析：加法算法正确实现。
2. 整数减法- 输入：10，4- 输出：6- 分析：减法算法正确实现。
3. 整数乘法- 输入：-2，5- 输出：-10- 分析：乘法算法正确实现。
4. 整数除法- 输入：20，3- 输出：6，2- 分析：除法算法正确实现。
七、实验总结通过本次实验，我们成功实现了整数加、减、乘、除运算的算法，并验证了算法的正确性。
在实验过程中，我们学习了位操作和位移操作在整数运算中的应用，提高了算法设计和编程能力。
大整数基本运算研究报告与实现分析
个人资料整理仅限学习使用大整数乘法的实现与分析摘要随着计算机信息安全要求的不断提高，密码学被大量应用到生活中。
RSA、ElGamal、DSA、ECC 等公钥密码算法和数字签名算法都建立在大整数运算的基础上，比较耗时的大整数乘法、除法、模乘、幂运算、幂乘等运算却被上述算法大量使用，它们的运算速度对这些算法的高效实现起着重要的作用，如何快速实现上述几种运算是公钥密码领域普遍关注的热点问题。
本文基于32位的系统，首先采用模块化的思想建立大整数运算库的基础框架，在实现一些辅助函数后在此框架上讨论并实现多精度大整数的基本加法、减法、乘法、除法、平方算法、缩减、模乘、模幂乘等算法。
所用程序均采用C/C++语言编写，所采用的优化也均建立在C/C++语言这一层面上，在保证算法有足够高的效率的同时力求代码清晰易懂，函数接口简单明了，具有可移植性和稳定性。
关键词：多精度大整数，Comba，Montgomery，二分查找，笔算注：本设计<论文）题目来源于企业工程。
AbstractNowadays, as computer information security requirements improve continuously, the cryptology has been widely applied to life. Public key cryptographic algorithms and digital signature algorithms such as RSA, ElGamal, DSA, ECC are all base on multiple precision arithmetic. Multiple precision multiplication,Division, modular multiplication ,exponen- tiation, modular exponentiation which need more working time is used by public key cryptographic algorithms widely, their speed is very important to the implementations of those algorithms. How to fast implement those arithmetic above is the hot topic in the public key cryptographic field.This paper is based on the 32 bit system. First of all,we found the modular foundation of multiple precision arithmetic library。
大整数相乘实验报告
一、实验目的1. 理解大整数相乘的基本原理和方法。
2. 掌握大整数相乘的编程实现。
3. 分析大整数相乘算法的效率，并优化算法。
二、实验原理大整数相乘是指对两个或多个大整数进行乘法运算。
在计算机科学中，大整数通常指的是位数超过计算机中普通整数类型的整数。
大整数相乘的方法有很多，常见的有长乘法、Karatsuba算法、FFT算法等。
本实验采用长乘法算法进行大整数相乘。
长乘法算法的基本原理是将乘数和被乘数按照一定的位数进行拆分，然后逐位相乘，最后将乘积相加得到最终结果。
具体步骤如下：1. 将乘数和被乘数分别拆分成若干个较小的部分。
2. 将每个较小的部分与另一个数对应的部分相乘。
3. 将乘积按照一定的位数对齐，并相加得到部分乘积。
4. 将所有部分乘积相加得到最终结果。
三、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 开发工具：PyCharm四、实验步骤1. 导入必要的库```pythondef multiply(a, b):# 省略实现细节pass2. 编写大整数相乘函数```pythondef multiply(a, b):# 将字符串转换为列表，列表中每个元素代表一位数字 a_list = list(map(int, a))b_list = list(map(int, b))# 初始化结果列表result = [0] (len(a_list) + len(b_list))# 遍历a_list和b_list的每一位for i in range(len(a_list)):for j in range(len(b_list)):# 将当前位相乘，并加上进位result[i + j] += a_list[i] b_list[j]# 处理进位result[i + j + 1] += result[i + j] // 10 # 将当前位设置为余数result[i + j] %= 10# 去除结果列表前面的0while len(result) > 1 and result[0] == 0:result.pop(0)# 将结果列表转换为字符串return ''.join(map(str, result))3. 测试大整数相乘函数```pythona = '12345678901234567890'b = '98765432109876543210'result = multiply(a, b)print(result)```4. 分析大整数相乘算法的效率长乘法算法的时间复杂度为O(n^2)，其中n为乘数和被乘数的位数。
数字整型算法实验报告(3篇)
第1篇一、实验目的1. 理解数字整型算法的基本原理和方法。
2. 掌握常用的数字整型算法，如整数乘法、除法、取余、排序等。
3. 培养算法设计与分析能力，提高编程实践能力。
二、实验内容1. 整数乘法算法2. 整数除法算法3. 整数取余算法4. 快速排序算法5. 堆排序算法三、实验原理1. 整数乘法算法：利用位运算，将两个整数进行逐位相乘，然后求和得到最终结果。
2. 整数除法算法：利用长除法原理，将除数逐步减去被除数的倍数，直到余数小于除数，此时商即为最终结果。
3. 整数取余算法：与整数除法类似，只需取除法的余数即可。
4. 快速排序算法：采用分治策略，将待排序的序列分为两部分，一部分大于等于基准值，另一部分小于基准值，然后递归地对这两部分进行排序。
5. 堆排序算法：利用堆这种数据结构，通过调整堆的性质来实现排序。
四、实验步骤1. 整数乘法算法实现```cint multiply(int a, int b) {int result = 0;while (b != 0) {if (b & 1) {result += a;}a <<= 1;b >>= 1;}return result;}```2. 整数除法算法实现```cint divide(int a, int b) {if (a == 0) return 0;int sign = (a > 0) ^ (b > 0) ? -1 : 1;long long dividend = abs((long long)a), divisor = abs((long long)b); long long quotient = 0;while (dividend >= divisor) {dividend -= divisor;quotient++;}return sign (int)quotient;}```3. 整数取余算法实现```cint remainder(int a, int b) {return a % b;}```4. 快速排序算法实现```cvoid quickSort(int arr[], int low, int high) { if (low < high) {int pivot = partition(arr, low, high); quickSort(arr, low, pivot - 1);quickSort(arr, pivot + 1, high);}}int partition(int arr[], int low, int high) { int pivot = arr[high];int i = low - 1;for (int j = low; j < high; j++) {if (arr[j] <= pivot) {i++;swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return i + 1;}```5. 堆排序算法实现```cvoid heapify(int arr[], int n, int i) {int largest = i;int left = 2 i + 1;int right = 2 i + 2;if (left < n && arr[left] > arr[largest]) { largest = left;}if (right < n && arr[right] > arr[largest]) { largest = right;}if (largest != i) {swap(&arr[i], &arr[largest]);heapify(arr, n, largest);}}void heapSort(int arr[], int n) {for (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, n, i);}for (int i = n - 1; i > 0; i--) {swap(&arr[0], &arr[i]);heapify(arr, i, 0);}}```五、实验结果与分析1. 整数乘法算法：通过位运算实现，效率较高，适用于大整数乘法运算。
长整数四则运算 实验报告
“数据结构”课程设计报告长整数四则运算学生姓名：吴成杰徐文良指导教师：陈少军所在系：电子信息系所学专业：计算机科学与技术年级：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）掌握分治法。
（2）学会测试和分析算法的时间性能二、分组：三个人一组，自由组合三、内容：1. 编写普通大整数乘法2. 编写基于分治的大整数乘法3. 编写改进的基于分治的大整数乘法4．编写一个随机产生数字的算法，分别产生两个10, 100, 1000, 10000, 100000位的数字a 和b，该数字的每一位都是随机产生的5. 用4所产生的数字来测试1、2和3算法的时间，列出如下表格。
(1)一直增长数字的位数，直到计算机内存溢出，算法无法继续进行下去。
(2)当位数较小时，乘法所需要的时间较短，这时候可以多次循环该算法，用平均时间来代表该算法的运行时间。
比如运行算法100次，得到时间是1.5秒，则该算法的执行时间是15毫秒。
6. 画出相应的散点图，其中x轴是矩阵的阶，y轴是所花费的时间，用不同的颜色表示不同的算法所花费的时间7. 思考（选做）：（1）在你的机器中，乘法是否比加法更费时？从哪里体现出来的？（2）如果要做更大规模的乘法，比如10亿亿位的两个数的乘法，你有什么方法来解决这个问题？四、实验要求1. 在blackboard (http:// /) 上进行分组，然后每组提交电子版实验报告。
2. 实验报告样式可从http://192.168.2.3/guide.aspx 表格下载－学生适用－在校生管理－实践教学－实验：深圳大学学生实验报告）3. 源代码作为实验报告附件上传。
4. 实验报告正文不要帖源代码＋实验指南，而是要完成相应的工作。
5. 实验人数：每组3人，自由组合。
实验报告中要指明每个人完成的内容，表格列出每个人的贡献（总体为100%，列出每个成员占的百分比）6. 在实验完成之后，将进行一次介绍。
做好PPT，由教师从每组中随机抽取一名同学来对实验内容进行介绍。
五、实验成绩实验成绩的给分标准是实验报告50%，PPT汇报50%。
每组成员的分数以小组分为基本分，然后按照每个成员的贡献进行浮动。
超长整数运算实验报告
江汉大学课程设计报告课程名称：数据结构设计题目：超长整数运算程序院（系）：数计学院专业：数学与应用数学组别：组长黄彬队员丁书山学生姓名:黄彬丁书山起止日期:指导教师:目录一、系统功能和结构1.1 程序设计目的1.2 需求分析1.3 概要设计1.3.1 主要数据结构描述1.3.2 算法分析及程序流程图1.4 任务安排二、程序实现2.1 模块详细设计2.2 核心代码详细解析三、调试与操作说明3.1 问题分析与解决3.2 程序演示四、设计体会与总结4.1 程序不足及功能扩充4.2 设计心得参考文献一、系统功能和结构1.1 程序设计目的1 超长整数运算【问题描述】编程实现无符号超长整数的算术运算（加、减、乘、除）。
【基本要求】加法运算结果可能产生进位；减法运算结果可以为负；如果被乘数分别为m、n位，则乘积可能为m+n位；除法运算要求输出整数商和余数。
运算数据可以由键盘输入或者随机产生，但位数不限，且其中不得包含数字以外的其它符号。
如果输入的数据不正确则显示“Input error.”。
系统运行界面自行设计。
例如:输入数据是：X=112233445566778899和Y=1234567890则显示结果为：X+Y=112233446801346789X-Y=112233444332211009X*Y=1385598080808080794349531101.3 概要设计1.3.1 主要数据结构描述本项目需要用到的主要数据结构：双向链表结构类型指针typedef struct Node{int data;struct Node *prior,*next;}Node,*NodeList;1.3.2 算法分析及程序流程图我的项目宏观地分为六大模块：输入、输出模块；预处理及杂项操作模块；加减法模块；乘法模块；主操作模块。
每个模块所包含的如图所示1.4 任务安排个人作业，此处略。
二、程序实现2.1 模块详细设计根据上面的流程图，下面分析每个模块具体的功能，包括每个模块的参数和得出的结果模块2.2模块9模块11模块122.2核心代码详细解析核心为乘法算法乘法的解析如图所示首先生成一个相当于链表长度之和的链表，每一格代表一个结点，然后分别计算每个结点内的乘法。
长整数加减运算实验报告
计算机存储的数据是有范围限制的，对于超出存储限制的数据无法直接在计算机中计算，为此需要设计相应的程序来完成这种超出范围限制的长整数间的四则运算。
设计一个实现任意长的整形数进行四则运算的程序，要求完成长整数的加、减运算，乘除运算可选做。
在这里长整数没有范围限制，可任意长。
运算后的进位、借位等都要进行正确处理，可实现动态的输入，实时的输出。
学习使用基本的数据结构解决实际应用中的问题，将学习的理论知识应用于实践，增强学生解决实际问题的能力。
这里可采用的基本数据结构为线性表。
1) 输入：动态输入以数字开头，可以任意长度，中间不用输入分隔符，直接输入即可。
2) 输出：实时输出的结果是加减运算后的结果。
3) 功能：实现长整数的加减运算。
4) 测试数据： 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”此实验采用的数据结构是双向循环链表。
这样可以很容易的找到他的前驱以及它的后继。
节点采用结构体类型，代码如下：typedef struct Node // 双向链表的结构体定义{int data;struct Node *prior;struct Node *next;}DLNode;1) void ListInitiate(DLNode **head)操作结果：初始化一个头结点为head 的双向循环链表；2) int ListLength(DLNode *head)操作结果：计算以head 为头结点的链表的长度3) int ListInsert(DLNode *head,int i,int x)操作结果：将节点数据为x 的节点插到第i 个位置上去。
4) int abs(int x)操作结果：绝对值函数，返回x 的绝对值。
5) int InputNumber(DLNode *head)操作结果：将从键盘中接收数据并把得到的数据存入以head 为头结点的链表中。
大整数乘法的实现与分析
课程设计大整数乘法的实现与分析课程名称______________________ 题目名称______________________ 学生学院______________________ 专业班级______________________ 学号______________________学生姓名______________________ 指导教师______________________2008年 6 月摘要随着计算机信息安全要求的不断提高,密码学被大量应用到生活中。
RSA、ElGamal、DSA、ECC 等公钥密码算法和数字签名算法都建立在大整数运算的基础上，比较耗时的大整数乘法、模乘、幂运算、模幂乘运算等却被上述算法大量使用，它们的运算速度对这些算法的高效实现起着重要的作用，如何快速实现上述几种运算是公钥密码领域普遍关注的热点问题。
本文基于32位的系统，首先采用模块化的思想建立大整数运算库的基础框架，在实现一些辅助函数后在此框架上讨论并实现多精度大整数的基本乘法、Comba乘法、Karatsuba乘法、各种平方算法、Barrett缩减、Mentgomery缩减、模乘、Mentgomery 模幂乘等算法及相关的算法。
本文讨论的所用程序均采用C语言编写，所采用的优化也均建立在C语言这一层面上，在保证算法有足够高的效率的同时力求代码清晰易懂，函数接口简单明了，具有可移植性和稳定性。
关键词：多精度大整数，缩减，模幂乘，滑动窗口AbstractNowadays, as computer information security requirements improve continuously, the cryptology is widely applied to life. Public key cryptographic algorithms and digital signature algorithms such as RSA, ElGamal, DSA, ECC are all base on multiple precision arithmetic. Multiple precision multiplication, modular multiplication ,exponentiation, modular exponentiation which need more working time is used by public key cryptographic algorithms widely, their speed is very important to the implementations of those algorithms. How to fast implement those arithmetic above is the hot topic in the public key cryptographic field.This paper is based on the 32 bit system. First, we found the modular foundation of multiple precision arithmetic library; After some auxiliary function is formed, we discuss and implement the multiple precision integer basic multiplication, Comba multiplication, Karatsuba multiplication, kinds of square algorithms, Barrett reduction, Montgomery reduction, Montgomery Modular Exponentiation algorithm and some relational function. All the algorithms discuss in this paper is implement entirely in portable ISO C and the optimization of those algorithms implementations is built on the c language level. Clear code, simple application programming interface is as important as the efficiency, the robustness and the portability.Key words:Multiple Precision Integer，Reduction，Modular Exponentiation，Sliding Window目录1 绪论 (1)1.1题目背景 (1)1.2国内外研究状况 (1)1.3本文构成及研究内容 (2)2 基础设置 (3)2.1大整数的表示 (3)2.2部分预定义的量 (4)2.3底层函数 (5)2.3.1 初始化大整数 (5)2.3.2 清除大整数 (6)2.3.3 扩展大整数的精度 (6)2.3.4 把一个大整数赋值给另一大整数 (6)2.3.5 格式化的表示 (6)3 特殊优化 (7)3.1字移位 (7)3.2乘以2或除以2 (7)3.3乘以或除以2的幂 (8)3.4模2的幂 (10)4 乘法 (12)4.1传统的乘法 (12)4.2使用C OMBA思想的乘法 (14)4.3只计算低半部或高半部的乘法 (17)4.4K ARATSUBA乘法 (17)4.5平方 (22)4.5.1 基本的平方算法 (22)4.5.2 使用Comba思想的平方 (24)4.5.3 Karatsuba平方 (26)5 模缩减 (27)5.1B ARRETT缩减 (27)5.2M ONTGOMERY缩减 (30)6 幂乘 (33)6.1幂乘概述 (33)6.1.1 字幂乘 (34)6.2K-RAY幂乘 (35)6.2.1 滑动窗口幂乘 (36)6.3模幂乘 (36)结论 (43)参考文献 (44)附录 (46)1 绪论1.1 题目背景科技的发展特别是网络的发展使计算机深入到了各行各业的方方面面，计算机在带来方便和提高了工作效率的同时却也带来了各种各样的新问题，其中信息安全问题最为突出，随着计算机信息安全要求的不断提高, 计算机保密系统已变得越来越重要，密码学应用不再是局限于军事、国防等有限领域，而是迅速的走进了千家万户，如CA 认证、电子政务、电子商务、数字签名、身份认证、密钥分发等。
课程设计 长整数四则运算
课程设计实验报告：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”。
密码学中大整数乘法的研究
（） ２
其 中 ｒ二Ｐｑ ｒ二Ｐ ２ ｐ＋Ｐ） ＋吼 。 ｏ， 口ｌ ｌ， 式（ ） ＝， ２ 执行 ３ 次乘法和 ４ 次加法， 换技巧町 ，ｅ ｂｈｇ－ ｔ ｓｅｌ 巧 ， ｑ￥ｈｎ ａｅＳｒ ｓｎ ａ ￣ 经典的Ｋ ｕｈ 减法基本运算 ， ｎ ｔ 如果 ｎ ２ ＞ 执行 ３ 次长度为 ｎ２的的 ／ 乘法运算 ， 也就是 ｐｑ，ｐｑ， －ｐ ＋ 还有 ２ ｏｏ ｔ－ｐ十 ｑ ， （ 乘 。 大多数乘法运算的技巧都是利用 “ 分治法” 次长 度 为 ｎ ／ ２的加 法 运算 ， 次 长 度为 ｎ的加 法 运 ２ 工具 ： 将—个大 的 乘法问题减小为一组较小的乘 算， 次长度为 ｎ的ａ， ２ ａ ｔ ￣运算。我们可以递归地利 ａｎ（ ｓｌ ［ ｎｏｖ ｅ ａｘ ， ｘ ， 设 １） （为计算 ｐ ｑ的计 ＊ 法问题 ， 但是一直用 同一个单一的方法进行递归 用分治法计算ｐｑ的乘积， １ｎ ｘ ｒｅ ｘ ｄ ｏ ｄ ，ｅ ｘ 到小问 题的做法被认为是错误的 选择目 。因为 ： 算时间， 则很容易地得到递归式 ： ｆ ７＂一 ２ ． ｍｕ Ｙ ｌ ａ 虽然有很多乘法运算 的技巧 ， 但是没有一 （ ｛（２ ５ ＞ ３ｎ ｎ ２ ） ７，＋ ， 一１ ｎ ；Ｐ ｏ ｕ ｔ ｉ ｄ ：ａ ｒ ｄ ｃ ｎ ｅ ｘｅ ｘ 种技巧适用于所有的情况 ，在操作数长度不同的 ｍｏ ｂ ，Ｐ ｖｅｘ 情况下 ，不同的乘法技巧所产生的效率是不一样 解此递归方程： ７ ＝９／ｏ １ ｍ） ｌ 一１ｎ—ｏ（ 。 ） ｌ ０ ／ｇ 的。所以应根据乘法运算 中的操作数长度的不 同 ｍｏ ｗ ｒ ｔ ｅ ｘ，ｅｘ ｖｄ ｏｄｐｒ［ ］ ａ ｂ 选择不同的算法 。 ４对大整数乘法的改进 ｍｏ ｗ ｒ ｔ ｅ ｘ４，ｅ ｘ ｖｄ ｏｄｐｒ『 ＋］ ｄ ｂ ｂ ． 通常情况下， 最佳的乘法运算算法应能在 优化大整数乘法的方法是 ， 首先利用分治法 】 递归的不同层次使用不 同的方法。 递归地调用 Ｋａａ ｕ ａ ｒｔ ｂ 乘法去减小乘法的规模 ， ｓ 当 表 １ 是经典 的 Ｋ ｕ 乘 法 、ａａ ｕ ａ ｎｔ ｈ Ｋ ｒｔ ｂ 乘法 ｓ 使用经典的 Ｋ ｕｈ 以及改进 的大整数乘法的 ‘ 时间比较结果 ， ｎ ｔ 算 其 主要 目标是 对 Ｋａａ ｕ ａ算 法进 行 改 进 ， ｒｔ ｂ ｓ 试 乘数 的长度达到某一个级别时， 中 Ｄｇｔ是 以 ２ ｉｉ ｓ 进制表示的乘数 的长度， 测试环 图找出这样一个条件并加以证明，当满足这个条 乘法进行剩下的乘法运算。 ＭＤ Ａ ｈｏ Ｃ Ｕ ． Ｈｚ ５ Ｍ ＡＭ， ｎ １ 件时基于分治法 的 Ｋ ｒｔ ｂ 乘法被反复递归地 ａａｓ ａ ｕ 定理 １ ：存在这样的 ｎ ，使得经典 的 Ｋ ｕｈ 境 是 Ａ ｔｌ Ｐ １ Ｇ ，２ ６ Ｒ ｎ ｔ ａａｓｂ 乘法 。 Ｗｉｄ ｗ Ｓ ｎ ｏ ｓＸＰＯ ，ＭＳＶ ｓａ ｃ ＋６ ｉｕｌ ＋ ． ０编译 器 。 调用， 当不满足这个条件时 ， 使用经典的 Ｋ ｕｈ ｎｔ 乘 乘法的计算时间小于 Ｋ ｒｔｕ ａ 表 １三种乘法的计算时间比较（ 单位： 秒） 法进行运算。 证明 ： Ｔ（ ， 分别表示经典的 Ｋ ｕｈ 设 。１ ｎ１ ｎｔ 乘 ＤＷ如 改 进的 法和 Ｋ ｒｔ ｂ 乘法的计算时间， ａａｓ ａ ｕ 根据前面的分析 １标记 ０ 进 制１ 乘 法 本文中所有的大整数都以 ｂ进制表示 ， 基本 可以得到： ０Ｄ１ （ ） ｔ ， ２ｎ ＝９ ＂ ＝ ／ ｒ（） ２ １ｎ ０ 的算术运算包括两个以 ｂ进制表示的单精度整数 ０Ｄ１ １ ４ ０２ ０Ｄ５ 的加、 乘、 减、 除。用 ｂ进制表示一个正整数 Ｐ通常 肯定存在这样的 ｎ 满足 Ｔｆ ￣ ｄ） １ Ｔ ｎ， ｎ 也就是 ２ ８ ０４ ０１ ３ ｎ ２ ・ ￣ １ｎ９ ｎ ， 到 ｎ ＜ ｎ －０ ＜ ・ 得 ９ ＜２－３ ２ ＜２＝２６ １ ２ …ｇ ｏ ５ 写成 ｐ Ｊ２ ， 中的单精度整数 Ｕ （≤ｉ ） ｕｕ…ｕ 其 １ ≤ｎ 称为数字，并且 ０ ， 一 。例如 ，如果 ｂ２ ： 也就是说当 ｎ ２ ６时，经典的 Ｋ ｕｈ ≤ｕ≤ｂ １ ＝ ＜５ ｎ ｔ乘法的效率 Ｏ １０ ００ ０ 那么 ０ ０ｆｆｆ 则整数（ｆｆ 要高 于 Ｋａａ ｕ ａ 法 。 ｘ ０ ００ ０ ， ≤ｕ￣ ｘｆｆｆ ＜ ｆｆ， ｆｆｆ ｆ ｆ ｒｔ ｂ 乘 ｓ 表 １显示 Ｋａａｓｂ 乘法的效率在实际中比 ｒｔ ａ ｕ 定理 ２ ：根据以下策略大整数乘法 的效率是 经典的 Ｋ ｕｈ乘法要低， ｎｔ 这与理论上是不一致的， ｆｆｆ 有两位数字。 ｆｆ０ ｆ ｂ ｆ 最高的： 如果ｎ ｌ（ －ｋ递归地调用 Ｋ ｒｔｕ ａ ＞ ６ｎ２ ， （ ） ａａｓｂ 乘 原因是 Ｋ ｒｔ ｂ 乘法涉及到大量的递归调用 ， ａａ ｕ ａ ｓ 在 ２经典的 Ｋ ｕ 乘法 以 ｎｔ ｂ 及它的计算时间 若 ｐｑ ｂ ， 是 进制表示 的非负整数 ， 。 … 法 ， ｎ ｌ ｐ ｕ 当 ＝６时递归调用返 回（ 递归出 口）调用经 此过程中要花费大量 的时间进行内存的请求与释 ， 放。 但是改进的乘法利用了 Ｋ ｒｔ ｂ 乘法和经典 ａａｓ ａ ｕ ｕｂ ｑ ｖ ２ 汕 ， ａ ， － 。…ｖ 它们的乘积 ｗ可表示成 ｗ ｑ 典的 Ｋ ｕｈ ４ ｖ ： ｎ ｔ乘法计算两个较小整数的乘积 。 （。 …ｗ ， ｗ 用经典 Ｋ ｕ 乘法 算 ｗ的算法 证 明 ： Ｔｎ表示 Ｋａ ｔ ｂ ｗ ｎｔ ｈ 计 设 ｆ １ ｒ ｓ ａ乘法的计算 时间 ， ａｕ 假 的 Ｋ ｕｈ ｎｔ 乘法的优点 ： 如果用 ２ 进制表示的乘数 设 如 果 ｎ ｍ时 Ｋ ｒｔ ｂ ＞ ａａｓ ａ乘法 被 递 归 地 调用 ， 的长度大于 １ ， ｒｔ ｂ ｕ 否 Ｋａ ｓ ａ乘法被不断地递归 ６时 ａｕ 可表示如下： ｓｅ ． Ｗ ｌ ｗ ， ， ｔ ｐ１ ， ２ … ｗ ， 则经典的 Ｋ ｕｈ乘法被调用。因此我们有 ： ｎｔ 调用 ， 而当长度是 １ ６时经典的 Ｋ ｕｈ ｎ ｔ 乘法被调用 ｓｅ ２ ｉ ｙ０ ｔ ｅ ｔ ｐ ． ｆ ｈ ｎ ｗ卜 ｇ ｔ ｔ ｐ ； ｖ ｏ ｏ ｓｅ ６ 用于计算两个较小整数的乘积。 从表 １ 也可看出， ，＿ｊ ｍ ＝ 。 一 ｌ ， ” ｓｅ ３ 卜１１ ｏ ｔｐ ． ．ｋ 、 Ｉ ’ ／ ） ５ ， ＞ｍ （ ２ ＋ ｎ＂ ３ ｎ １ 改进的大整数乘法算法比 Ｋ ｕｈ 法和 Ｋ ｒｔｕ ｎ ｔ乘 ａａｓ— ａ ｓ ｐ． ｔ １ ｔ ￣ ｌ ｅ ｋ ｔ ，ｗ ￣ｍｏ ，ｌ ｌｂ ｄｂ （ ｒ ： ｉＪ 一 令 ｎ２ ｈ ） ｌ （ ， １ ） ＝ （＝ （ ２ 那么 １ 能写成如下 ｂ 乘法明显地减少 了计算时间。 ， ｋＴ） ， ｎ １ （ ｎ
大数相乘
一、实验题目：用叠加法或分治法实现大整数的相乘二、实验内容：这种算法的思想是按照部分积的权值从低到高的顺序，每次计算出所有权值为i r的部分积，同时完成它们之间的累加，然后再计算权值更高的部分积，依次类推，直到计算出所有的部分积。
三、设计思想：叠加算法就是通用的笔算算法思想。
在两个大整数相乘中，它用第一个数的每一位去乘第二个数的每一位，再把运算结果按权值叠加，进位处理后，得到所求的结果四、代码：#define MAXLENGTH 1000#include <stdio.h>#include <string.h>void compute(char * a, char * b, char * c);void main(){char a[MAXLENGTH],b[MAXLENGTH],c[MAXLENGTH*2];puts("输入因数1:");gets(a);puts("输入因数2:");gets(b);compute(a,b,c);puts("积:");puts(c);getchar();}void compute(char * a,char * b,char * c){int i,j,m,n;long sum,carry;m=strlen(a)-1;n=strlen(b)-1;for (i=m;i>=0;i--)a[i]-='0';for (i=n;i>=0;i--)b[i]-='0';c[m+n+2]='\0';carry=0;for(i=m+n;i>=0;i--) /* i 为坐标和*/{sum=carry;if((j=i-m)<0)j=0;for(;j<=i&&j<=n;j++) /* j 为纵坐标*/sum+=a[i-j]*b[j]; /* 累计一组数的和*/c[i+1]=sum%10+'0'; /* 算出保留的数字*/carry=sum/10; /* 算出进位*/}if((c[0]=carry+'0')=='0') /* if no carry, */c[0]='\040'; /* c[0] equals to space */}五、实验结果（截图）：六、实验心得：这次实习让我学习到了好多东西，也认识到了自己好多方面的不足，我一定在今后的学习还是生活中更加的努力，不要让自己落后与人。
大整数乘法-实验报告
实验1 大整数乘法一、实验要求1．要求至多能处理两个200位的十进制整数相乘；2．要求交互式输入大整数；3．要求显示相乘结果。
二、实验仪器和软件平台仪器：带usb接口微机软件平台：WIN-XP + VC++6.0三、源程序#include "stdafx.h"#include <iostream>#include <sstream>#include <string>using namespace std;//string字符串变整数型int string_to_num(string k){int back;stringstream instr(k);instr>>back;return back;}//整形转换为string类型string num_to_string(int intValue){string result;stringstream stream;stream << intValue;//将int输入流stream >> result;//从stream中抽取前面放入的int值return result;}//在字符串str前添加s个零string stringBeforeZero(string str,int s){for(int i=0;i<s;i++){str.insert(0,"0");}return str;}//两个大整数字符串相加string stringAddstring(string str1,string str2){//假定str1和str2是相等的长度，不相等时在前面自动补零，使两个字符串长度相等if (str1.size() > str2.size()){str2 = stringBeforeZero(str2,str1.size() - str2.size());}else if (str1.size() < str2.size()){str1 = stringBeforeZero(str1,str2.size() - str1.size());}string result;int flag=0;//前一进位是否有标志,0代表无进位，1代表有进位for(int i=str1.size()-1;i>=0;i--){//利用ASCII码对字符进行运算,这里加上flag代表的是:当前一位有进位时加1，无进位时加0int c = (str1[i] - '0') + (str2[i] - '0') + flag;flag = c/10;//c大于10时，flag置为1，否则为0c %= 10;//c大于10时取模，否则为其本身result.insert(0,num_to_string(c));//在result字符串最前端插入新生成的单个字符}if (0 != flag) //最后一为(最高位)判断，如果有进位则再添一位{result.insert(0,num_to_string(flag));}return result;}//两个大整数字符串相减string stringSubtractstring(string str1,string str2){//对传进来的两个数进行修剪，如果前面几位有0则先去掉，便于统一处理while ('0' == str1[0]&&str1.size()>1){str1=str1.substr(1,str1.size()-1);}while ('0' == str2[0]&&str2.size()>1){str2=str2.substr(1,str2.size()-1);}//使两个字符串长度相等if (str1.size() > str2.size()){str2 = stringBeforeZero(str2,str1.size() - str2.size());}string result;for(int i=str1.size()-1;i>=0;i--){int c = (str1[i] - '0') - (str2[i] - '0');//利用ASCII码进行各位减法运算if (c < 0) //当不够减时向前一位借位，前一位也不够位时再向前一位借位{c +=10;int prePos = i-1;char preChar = str1[prePos];while ('0' == preChar){str1[prePos]='9';prePos -= 1;preChar = str1[prePos];}str1[prePos]-=1;}result.insert(0,num_to_string(c));//在result字符串最前端插入新生成的单个字符}return result;}//在字符串str后跟随s个零string stringFollowZero(string str,int s){for(int i=0;i<s;i++){str.insert(str.size(),"0");}return str;}//大整数乘法的实现函数string IntMult(string x,string y){//对传进来的第一个数进行修剪，如果前面几位有0则先去掉，便于统一处理while ('0' == x[0]&&x.size()>1){x=x.substr(1,x.size()-1);}//对传进来的第二个数进行修剪，如果前面几位有0则先去掉，便于统一处理while ('0' == y[0]&&y.size()>1){y=y.substr(1,y.size()-1);}int f=4;if (x.size()>2 || y.size()>2){if (x.size() >= y.size()) //x的数长度>=y的数长度的情况{while (x.size()>f) //判断x的数据长度是否大于f的值{f*=2;}if (x.size() != f){x = stringBeforeZero(x,f-x.size());y = stringBeforeZero(y,f-y.size());}}else //x.size() < y.size()的情况{while (y.size()>f){f*=2;}if (y.size() != f){x = stringBeforeZero(x,f-x.size());y = stringBeforeZero(y,f-y.size());}}}//数据长度为1时,在前面补一个0if (1 == x.size()){x=stringBeforeZero(x,1);}if (1 == y.size()){y=stringBeforeZero(y,1);}//校正数据，确保x和y的数据长度统一if (x.size() > y.size()){y = stringBeforeZero(y,x.size()-y.size());}if (x.size() < y.size()){x = stringBeforeZero(x,y.size()-x.size());}//校正后，使得x.size=y.sizeint s = x.size();string a1,a0, b1,b0;if( s > 1){a1 = x.substr(0,s/2);a0 = x.substr(s/2,s-1);b1 = y.substr(0,s/2);b0 = y.substr(s/2,s-1);}string result;if( s == 2) //长度为2时代表着递归的结束条件{//将string字符串变整数型int na = string_to_num(a1);int nb = string_to_num(a0);int nc = string_to_num(b1);int nd = string_to_num(b0);//将x和y直接相乘，得到的整数转换为string类型result = num_to_string((na*10+nb) * (nc*10+nd));}else{//长度不为2时利用分治法进行递归运算string c2 = IntMult(a1,b1);// c2=(a1 * b1)string c0 = IntMult(a0,b0);// c0=(a0 * b0)string c1_1 = stringAddstring(a1,a0);// (a1 + a0)string c1_2 = stringAddstring(b1,b0);// (b1 + b0)string c1_3 = IntMult(c1_1,c1_2);// (a1 + a0)*(b1 + b0)string c1_4 = stringAddstring(c2,c0);// (c2 + c0)string c1=stringSubtractstring(c1_3,c1_4);// c1=(a1 + a0)*(b1 + b0)-(c2 + c0)string s1=stringFollowZero(c1,s/2);//在字符串c1后跟随s/2个零，即：算术左移s/2位。
(完整word版)长整数四则运算实验报告
一、需求分析设计一个实现任意长的整数间进行四则运算的程序，要求完成长整数的加、减运算，乘除运算可选做。
在这里长整数没有范围限制，可任意长。
运算后的进位、借位等都要进行正确处理，可实现动态的输入，实时的输出。
测试数据：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，1111；1，1111 输出“0”二、概要设计1、数据结构利用双向循环链表来实现对长整数的存储。
选择该数据结构来完成长整数的加减运算是因为a.要对长整数进行运算，需要对长整数进行存储，选择用链表对长整数存储。
b.存储的顺序是从左到右，运算的顺序则是从右到左，为操作方便选择循环链表。
c.在运算过程中有进位和借位的操作。
2、使用算法三、详细设计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、输入0和0做加法运算，输出“0”，结果如下图：2、输入2345，6789和-7654，3211做减法运算，输出“1，0000，0000”，结果如下图：3、输入1，0000，0000，0000和9999，9999做减法运算，输出“9999，0000，0001”，结果如下图：4、输入1，0001，0001和1，0001，0001做减法运算，输出“0”，结果如下图：5、输入1，1111和1，1111做减法运算，输出“0”结果如下图：六、心得体会本次实验主要是针对双向链表的练习，通过这次试验我们大家对于双向循环链表有了更深刻的记忆。
大整数的乘法实验分析报告
大整数的乘法实验报告————————————————————————————————作者：————————————————————————————————日期：算法设计与分析实验报告姓名：XXX班级：XXX学号：XXX一、实验名称：大整数的乘法时间：2012年3月7日，星期三，第四节地点：12#311二、实验目的及要求实现大整数相乘，需要处理很大的整数，它无法在计算机硬件能直接表示的整数范围内进行处理。
若用浮点数来表示它，则只能近似的表示它的大小，计算结果中的有效数字也受到限制。
如要精确地表示大整数并在计算结果中要求精确地得到所有位数上的数字，就必须用软件的方法来实现大整数的算术运算。
三、实验环境Vc++。
四、实验内容从键盘上输入两个大整数，实现两个大整数相乘，并输出结果。
例如：在键盘上输入两个数a，b。
a=9876543210；b=369852147；五、算法描述及实验步骤定义三个数组a[100]，b[100]，c[199]。
用数组a来存放大整数a，a[0]=9,a[1]=8,a[2]=7,a[3]=6,a[4]=5,a[5]=4,a[6]=3, a[7]=2,a[8]=1,a[9]=0；用数组b来存放大整数b，b[0]=3,b[1]=6,b[2]=9,b[3]=8,b[4]=5,b[5]=2,b[6]=1 b[7]=4,b[8]=7。
用数组c来存放数组a和b每一位的乘积，c[0]=a[0]*b[0];c[1]=a[1]*b[0]+a[0]*b[1];c[2]=a[2]*b[0]+a[1]*b[1]+a[0]*b[2];…………c[17]=a[9]*b[8];六、调试过程及实验结果void make(int a[],int aa,int b[],int bb,int c[]){int i,j;for(i=0;i<aa;i++){if(a[i]==0) continue;for(j=0;j<bb;j++)c[i+j]+=a[i]*b[j];}for(i=0;i<aa+bb-1;i++){c[i-1]+=c[i]/10;c[i]=c[i]%10;}printf("\nc=");for(i=0;i<aa+bb-1;i++)printf("%d",c[i]);}程序运行结果：更改程序后：void make(int a[],int aa,int b[],int bb,int c[]){int i,j;for(i=0;i<aa;i++){if(a[i]==0) continue;for(j=0;j<bb;j++)c[i+j]+=a[i]*b[j];}for(i=aa+bb-2;i>0;i--){c[i-1]+=c[i]/10;c[i]=c[i]%10;}printf("\nc=");for(i=0;i<aa+bb-1;i++)printf("%d",c[i]);}运行结果：七、总结本程序的的时间复杂度太大O(aa*bb)，但是解决了大整数相乘硬件无法完成的问题。
大数阶乘的实验报告
一、实验目的1. 了解大数阶乘的概念和计算方法。
2. 掌握大数阶乘的编程实现。
3. 分析大数阶乘的计算效率和存储方法。
二、实验背景阶乘是数学中的一个重要概念，表示为n!，其中n为正整数。
阶乘的计算公式为：n! = n × (n-1) × (n-2) × ... × 2 × 1。
随着n的增大，阶乘的值会迅速增大，超出常规数据类型的表示范围。
因此，大数阶乘的计算成为了一个重要的研究课题。
三、实验内容1. 大数阶乘的定义和性质2. 大数阶乘的计算方法3. 大数阶乘的编程实现4. 大数阶乘的计算效率和存储方法四、实验步骤1. 理解大数阶乘的定义和性质2. 学习大数阶乘的计算方法3. 使用编程语言实现大数阶乘的计算4. 分析大数阶乘的计算效率和存储方法五、实验结果与分析1. 大数阶乘的定义和性质阶乘的定义：n! = n × (n-1) × (n-2) × ... × 2 × 1，其中n为正整数。
阶乘的性质：（1）n! > n^2，当n≥5时；（2）n! > 2^n，当n≥14时；（3）n! > 3^n/2，当n≥18时。
2. 大数阶乘的计算方法大数阶乘的计算方法有很多种，以下介绍几种常用的方法：（1）递归法：递归法是一种简单的大数阶乘计算方法，但效率较低。
（2）迭代法：迭代法是一种效率较高的大数阶乘计算方法，适用于计算较小的阶乘。
（3）快速幂法：快速幂法是一种高效的大数阶乘计算方法，适用于计算较大的阶乘。
3. 大数阶乘的编程实现以下是一个使用Python语言实现的大数阶乘的示例代码：```pythondef factorial(n):if n == 0 or n == 1:return 1else:return n factorial(n-1)n = int(input("请输入要计算的阶乘数："))result = factorial(n)print(f"{n}的阶乘为：{result}")```4. 大数阶乘的计算效率和存储方法（1）计算效率：递归法的效率较低，迭代法和快速幂法效率较高。
大数乘法算法实验报告
一、实验目的1. 理解大数乘法算法的基本原理。
2. 掌握大数乘法算法的实现方法。
3. 分析大数乘法算法的复杂度，并比较不同算法的效率。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 开发工具：PyCharm三、实验内容本次实验主要涉及以下大数乘法算法：1. 模拟乘法算法2. Karatsuba算法3. 快速傅里叶变换（FFT）算法（一）模拟乘法算法1. 原理模拟乘法算法通过模拟手工乘法过程，逐位计算乘积，并处理进位问题。
该算法适用于任意位数的大数乘法。
2. 实现步骤（1）创建一个长度为max(len(a), len(b))+1的数组c，用于存储乘积。
（2）从被乘数的最低位开始，依次与乘数的每一位相乘，并处理进位。
（3）将乘积的每一位存储到数组c中。
（4）遍历数组c，处理进位问题。
3. 代码实现```pythondef multiply(a, b):len_a, len_b = len(a), len(b)c = [0] (len_a + len_b)for i in range(len_a - 1, -1, -1):for j in range(len_b - 1, -1, -1):c[i + j + 1] += int(a[i]) int(b[j])c[i + j] += c[i + j + 1] // 10c[i + j + 1] %= 10return ''.join(map(str, c)).lstrip('0')```（二）Karatsuba算法1. 原理Karatsuba算法是一种分治算法，通过将大数分解为较小的数，降低乘法操作的复杂度。
2. 实现步骤（1）将两个大数a和b分解为a1、a0、b1、b0，其中a = a1 10^(n/2) + a0，b = b1 10^(n/2) + b0。
（2）计算以下四个值：1. x1 = a1 b12. x2 = (a1 + a0) (b1 + b0) - x1 - x03. x0 = a0 b04. x3 = x1 10^n + x2 10^(n/2) + x0（3）将x3的每一位转换为字符串，拼接成最终结果。
大整数乘法实验报告
大整数乘法实验报告实验报告--大整数实验报告题目：班级：计算机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类提供任意精度的整数运算。
大整数基本运算实现研究报告及分析
4.32 乘法运算代码实现 12 4.33 数据测试结果 14 4.4 除法运算 14 4.41 除法运算代码实现 14 4.42 数据测试结果 16
结论 17
参考文献 17
附录 A17
个人资料整理 仅限学习使用
个人资料整理 仅限学习使用
1 绪论
储不大于 310 位的大整数，在实现一些辅助函数后在此运算库框架上讨论并实现多精
度大整数的基本加法、减法、乘法、除法等基本算法。本文采用
C++为主要语言编写
程序代码。在保证算法有足够高的效率的同时力求代码清晰易懂，函数接口简单明
了，具有可移植性和稳定性。
2大整数概述
2.1 本文研究的大整数特定含义
为了系统地研究大整数的处理，本文提到的大整数处理程序中所指的大整数是指 最大位数为 310位的大整数。采用数组存储方式存储。
CBigInt Euc(CBigInt& A> 。
CBigInt RsaTrans(CBigInt& A, CBigInt& B>
。
}。
3.3 本章小结
基于面向对象程序设计开发的基本思想，本章介绍了大整数“类”的结构，包括大 整数的构造，加，减，乘，除基本运算的函数模块和大整数的获取、赋值函数模块。
3 大整数的类的开发 3
3.1 如何表示一个大整数 (12345678901234567890>3 3.2 用 C++ 编写大整数类 3 3.3 本章小结 5
4 基本运算的原理和代码实现 5
4.1 加法运算 5 4.11 实现原理 5 4.12 代码实现 6 4.13 数据测试结果 8
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
算法设计与分析实验报告
姓名：XXX
班级：XXX
学号：XXX
一、实验名称：大整数的乘法
时间：2012年3月7日，星期三，第四节
地点：12#311
二、实验目的及要求
实现大整数相乘，需要处理很大的整数，它无法在计算机硬件能直接表示的整数范围内进行处理。
若用浮点数来表示它，则只能近似的表示它的大小，计算结果中的有效数字也受到限制。
如要精确地表示大整数并在计算结果中要求精确地得到所有位数上的数字，就必须用软件的方法来实现大整数的算术运算。
三、实验环境
Vc++。
四、实验内容
从键盘上输入两个大整数，实现两个大整数相乘，并输出结果。
例如：在键盘上输入两个数a，b。
a=9876543210；
b=369852147；
五、算法描述及实验步骤
定义三个数组a[100]，b[100]，c[199]。
用数组a来存放大整数a，a[0]=9,a[1]=8,a[2]=7,a[3]=6,a[4]=5,a[5]=4,a[6]=3, a[7]=2,a[8]=1,a[9]=0；
用数组b来存放大整数b，b[0]=3,b[1]=6,b[2]=9,b[3]=8,b[4]=5,b[5]=2,b[6]=1 b[7]=4,b[8]=7。
用数组c来存放数组a和b每一位的乘积，
c[0]=a[0]*b[0];
c[1]=a[1]*b[0]+a[0]*b[1];
c[2]=a[2]*b[0]+a[1]*b[1]+a[0]*b[2];
……
……
c[17]=a[9]*b[8];
六、调试过程及实验结果
void make(int a[],int aa,int b[],int bb,int c[]){
int i,j;
for(i=0;i<aa;i++){
if(a[i]==0) continue;
for(j=0;j<bb;j++)
c[i+j]+=a[i]*b[j];
}
for(i=0;i<aa+bb-1;i++){
c[i-1]+=c[i]/10;
c[i]=c[i]%10;
}
printf("\nc=");
for(i=0;i<aa+bb-1;i++)
printf("%d",c[i]);
}
程序运行结果：
更改程序后：
void make(int a[],int aa,int b[],int bb,int c[]){
int i,j;
for(i=0;i<aa;i++){
if(a[i]==0) continue;
for(j=0;j<bb;j++)
c[i+j]+=a[i]*b[j];
}
for(i=aa+bb-2;i>0;i--){
c[i-1]+=c[i]/10;
c[i]=c[i]%10;
}
printf("\nc=");
for(i=0;i<aa+bb-1;i++)
printf("%d",c[i]);
}
运行结果：
七、总结
本程序的的时间复杂度太大O(aa*bb)，但是解决了大整数相乘硬件无法完
成的问题。
上机经验和体会：因注意循环体部分和循环条件，此处时容易出错的地方。
八、附录（源程序清单）
#include<stdio.h>
#define A 100
#define B 100
int getnumber(char a[],int b[]){
int i=0;
while(a[i]!='\0'){
b[i]=a[i]-48;
i++;
}
return i;
}
void make(int a[],int aa,int b[],int bb,int c[]){
int i,j;
for(i=0;i<aa;i++){
if(a[i]==0) continue;
for(j=0;j<bb;j++)
c[i+j]+=a[i]*b[j];
}
for(i=aa+bb-2;i>0;i--){
c[i-1]+=c[i]/10;
c[i]=c[i]%10;
}
printf("\nc=");
for(i=0;i<aa+bb-1;i++)
printf("%d",c[i]);
}
main(){
int aa,bb,i,a[A]={0},b[B]={0},c[A+B]={0};
char a1[A],b1[B];
printf("请输入一个数a:");
gets(a1);
aa=getnumber(a1,a);
printf("a=");
for(i=0;i<aa;i++)
printf("%d",a[i]);
printf("\n请输入另一个数b:");
gets(b1);
bb=getnumber(b1,b); printf("b=");
for(i=0;i<bb;i++)
printf("%d",b[i]); make(a,aa,b,bb,c); printf("\n");
}。