大整数乘法

最新推荐文章于 2025-09-07 18:41:56 发布
最新推荐文章于 2025-09-07 18:41:56 发布
阅读量84 收藏 1
点赞数
文章标签： c/c++
本文详细介绍了使用分治法解决大整数乘法问题的算法，包括其工作原理、效率分析及C语言实现。通过将大整数分解为小部分并递归地计算它们的乘积，该算法显著提高了大整数乘法的效率。

分治法的应用

【算法】

Mul(A[0…n-1], B[0…n-1], n)

//计算两个大整数A[], B[]的乘积

//输入：字符数组（或字串）表示的两个大整数

//输出：以字串形式输出的两个大整数的乘积

if (n == 1)

       return A[0] * B[0];

//高位补0，使n成为偶数（二分需要）

if (n%2 == 0)

{

       A[0…n] =  ‘0’ + A[0…n-1] ;

       B[0…n] =  ‘0’ + B[0…n-1] ;

       n++;

}

//进行二分

a1 = A[0, n/2];     //A的前半部分

a0 = A[n/2, n-1];   //A的后半部分

b1 = B[0, n/2];     //B的前半部分

b0 = B[n/2, n-1];   //B的后半部分

/*那么A = a1*10^n/2 + a0   B = b1*10^n/2 + b0

  利用与计算两位数相同的方法可以得到：

c = a*b = (a1*10^n/2 + a0)*(b1*10^n/2 + b0)

        = (a1*b1)10^n + (a1*b0 + a0*b1)10^n/2 + (a0*b0)

        =c2*10^n + c1*10^n/2 + c0

其中，c2 = a1 * b1, 是它们前半部分的积，c0 = a0 * b0，是它们后半部分的积

c1 = (a1*b0 + a0*b1) = (a1 + a0) * (b1 + b0) – (c2 + c0) ----利用已经算出来的积(c2, c0)，减少乘法的数量(2次 à 1 次)

*/

c2 = Mul(a1, b1);

c0 = Mul(a0, b0);

c1 = Mul(a1+a0, b1+b0) – (c2 + c0);

return c2*10^n + c1*10^n/2 + c0;

 

【效率分析】

该算法会做多少次位乘呢？因为n位数的乘法需要对n/2位数做三次乘法运算，乘法次数M(n)的递推式将会是：

                                   当n>1时，M(n) = 3M(n/2)， M(1) = 1

当n = 2^k时， 我们可以利用反向替换法对它求解：

                     M(2^k) = 3M( 2^(k-1) ) = 3^2 M( 2^(k-2)

                  = 3^k M(2^(k-k)) = 3^k

因为k = log2n，

                            M(n) = 3log2n = n^1.585；

 

【C语言实现】

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

//支持的大整数的位数
#define  N 1000

/*
	@brief reverse a string 
*/
void reverseStr(char *A, int n)
{
	int i = 0, j = n-1;
	char temp;

	while (i < j)
	{
		temp = A[i];
		A[i] = A[j];
		A[j] = temp;
		i++;
		j--;
	}
}
/*
	@brief return the maximum of three numbers 
*/
int max3(int a, int b, int c)
{
	if (a>b)
	{
		return a>c?a:c;
	}
	else 
		return b>c?b:c;
}

/*
	@brief caculate the difference of A, B, restore the result in C. 
	       the three numbers are represented in the form of string
*/
void substract2str(const char *A, const char *B, int n, char *C)
{
	int i, borrow = 0;
	
	for (i = 0; i<n; i++)
	{
		if (A[i] - borrow >= B[i])
		{
			C[i] = (A[i] - B[i] - borrow) + '0';
			borrow = 0;
		}
		else
		{
			C[i] = (A[i] +10 - B[i] - borrow) + '0';
			borrow = 1;
		}
	}
}
/*
	@brief caculate the sum of A, B, restore the result in C. 
	       the three numbers are represented in the form of string
*/
void add2str(const char *A, const char *B, int n, char *C)
{
	int i, sum, carry;

	carry = 0;

	for (i = 0; i<n; i++)
	{
		sum = (A[i] - '0') + (B[i] - '0')+carry;
		C[i] = sum%10 + '0'; //int --> char
		carry = sum/10;
	}
	if (carry)
		C[i] = '1';
}

/*
	@brief return the product of two big integers A, B, which are represented in
	 the form of string, also the product.
*/
char* Mul(char *A, char *B, size_t n)
{
	//一位数相乘，直接返回结果
	if (n == 1)
	{
		char *rst = (char *)malloc(3*sizeof(char));
		if (rst == NULL)
		{
			printf("Allocate memory failed!\n");
			exit(1);
		}
		rst[2] = 0;

		int temp = (A[0] - '0') * (B[0] - '0');
		rst[0] = temp%10 + '0';
		if (temp/10)
			rst[1] = temp/10 + '0';
		else
			rst[1] = 0;
		return rst;
	}
	
	//高位补0，使n为偶数
	if (n % 2 != 0)
	{
		*(A+n) = '0';
		*(B+n) = '0';
		n++;
	}
	char *a0 = A;     //A 的后半部分
	char *a1 = A + n/2; //A 的前半部分
	char *b0 = B;     //B 的后半部分
	char *b1 = B + n/2; //B 的前半部分
	size_t i;

	//多分配一位，因为下一层次的计算中有可能要补一位
	char *tp1 = (char *)calloc(n/2+2, sizeof(char));
	char *tp2 = (char *)calloc(n/2+2, sizeof(char));
	
	strncpy(tp1, a1, n/2);
	strncpy(tp2, b1, n/2);
	char *c2 = Mul(tp1, tp2, n/2);
	strncpy(tp1, a0, n/2);
	strncpy(tp2, b0, n/2);
	char *c0 = Mul(tp1, tp2, n/2);
	free(tp1); tp1 = NULL;
	free(tp2); tp2 = NULL;
	//两个乘积对齐
	if (strlen(c2) > strlen(c0))
	{
		for (i=strlen(c0); i<strlen(c2); i++)
		{
			c0[i] = '0';
		}
	}
	else if (strlen(c2) < strlen(c0))
	{
		for (i=strlen(c2); i<strlen(c0); i++)
		{
			c2[i] = '0';
		}
	}
	char *pa;
	//两个n/2位数的和，可能为n/2 + 1位
	size_t len = n/2+2;

	pa = (char *)calloc(len, sizeof(char));
	if (pa == NULL)
	{
		printf("Allocate memory failed!\n");
		exit(1);
	}	
	add2str(a1, a0, n/2, pa);

	char *pb = (char *)calloc(len, sizeof(char));
	if (pb == NULL)
	{
		printf("Allocate memory failed!\n");
		exit(1);
	}	
	add2str(b1, b0, n/2, pb);

	len = strlen(pa)>strlen(pb)?strlen(pa):strlen(pb);
	//对齐pa和pb
	if (len > strlen(pa))
	{
		pa[len-1] = '0';
	}
	else if (len > strlen(pb))
	{
		pb[len-1] = '0';
	}
	char *pd;
	pd = Mul(pa, pb, len);
	len = strlen(pd);
	
	free(pa); pa=NULL;
	free(pb); pb=NULL;
	//两个n位数的积的位数肯定大于两个n位数的和的位数
	char *pc = (char *)calloc((len+1), sizeof(char));
	if (pc == NULL)
	{
		printf("Allocate memory failed!\n");
		exit(1);
	}
	add2str(c2, c0, strlen(c0), pc);

	//pd  pc 对齐
	for (i=strlen(pc); i<len; i++)
		pc[i] = '0';
	//两个n位数的差最多为n位数
	char *c1 = (char *)calloc((len+1), sizeof(char));
	if (c1 == NULL)
	{
		printf("Allocate memory failed!\n");
		exit(1);
	}
	substract2str(pd, pc, len, c1);
	
	free(pd); pd = NULL;
	free(pc); pc = NULL;

	//两个n位数的乘积最多为2n位数
	char *tpc0 = (char *)calloc((2*n+1), sizeof(char));
	char *tpc1 = (char *)calloc((2*n+1), sizeof(char));
	char *tpc2 = (char *)calloc((2*n+1), sizeof(char));
	if (tpc0 == NULL || tpc1 == NULL || tpc2 == NULL)
	{
		printf("Allocate memory failed!\n");
		exit(1);
	}
	len = 2*n;
	
	//为了计算方便，都补齐到2n位
	strcpy(tpc0, c0);
	for (i=strlen(c0); i<len; i++)
		tpc0[i] = '0';
	tpc0[len] = 0;

	strncpy(tpc1+n/2, c1, len-n/2);
	for (i=0; i<n/2; i++)
		tpc1[i] = '0';
	for (i=n/2+strlen(c1); i<len; i++)
		tpc1[i] = '0';
	tpc1[len] = 0;
	//在此遇到内存错误，如果用strcpy(tpc+n, c2) -- C语言一定要注意内存的操作，确定不会越界吗？
	strncpy(tpc2+n, c2, len-n);
	for (i=0; i<n; i++)
		tpc2[i] = '0';
	for (i=n+strlen(c2); i<len; i++)
		tpc2[i] = '0';
	tpc2[len] = 0;
	
	free(c0); c0=NULL;
	free(c1); c1=NULL;
	free(c2); c2=NULL;
	char *rst = (char *)calloc((2*n+1), sizeof(char));
	char *tmp = (char *)calloc((2*n+1), sizeof(char));
	if (rst == NULL || tmp == NULL)
	{
		printf("Allocate memory failed!\n");
		exit(1);
	}
	add2str(tpc2, tpc0, len, tmp);
	add2str(tmp, tpc1, strlen(tmp), rst);
	free(tpc0); tpc0 = NULL;
	free(tpc1); tpc1 = NULL;
	free(tpc2); tpc2 = NULL;
	free(tmp);  tmp = NULL;

	return rst;
}

int main()
{
	char *A = (char *)calloc(N+1, sizeof(char));
	char *B = (char *)calloc(N+1, sizeof(char));
	size_t i;
	char *rst;
	do 
	{
		printf("input A: ");
		scanf("%s", A);
		printf("input B: ");
		scanf("%s", B);	
		/*
		  如果我们是按高位 --> 地位顺序输入， 则A的低地址存的是最高位的数。
		  比如输入95432，那么内存中会是这样的A[0] A[1] ... A[0] : 9 5 ... 2
		  而我们的算法是建立在低地址存最低位基础上的，所以需要一个reverse操作。
		*/
		reverseStr(A, strlen(A));
		reverseStr(B, strlen(B));
	
		//对齐A和B --> 通过高位补零
		if (strlen(A) > strlen(B))
		{
			for (i=strlen(B); i<strlen(A); i++)
				B[i] = '0';
		}
		else if (strlen(A) < strlen(B))
		{
			for (i=strlen(A); i<strlen(B); i++)
				A[i] = '0';
		}		
	
		rst = Mul(A, B, strlen(A));
		reverseStr(rst, strlen(rst));
		//remove the leading zero
		for (i=0; i<strlen(rst); i++)
			if (rst[i] != '0')
				break;
		if (i!=strlen(rst))
			puts(rst+i);
		else
			puts("0");
		free(rst);
	} while( !((A[0] == '0' && strlen(A) == 1) && (B[0] == '0' && strlen(B) == 1))); //输入零结束	
	free(A);
	free(B);

	return 0;
}

【分治算法之大整数乘法】---C++实现
追光者♂：记录、分享、总结、提升，现象级专栏《Python从入门到人工智能》作者，无惧黑暗，坚信曙光
10-29 7376
题目 大整数乘法：用分治算法编程实现两个n位十进制大整数的乘法运算。 一种较为流行的思路（即分治） 分析 <大整数的乘法> 在计算机中，长整形（long int）变量的范围不能超过10位数。 即便用双精度（double）变量，也仅能保证16位有效数字的精度。在某些需要更高精度的乘法运算场合，需要用别的办法来实现运算。 比较容易想到的是做多位数乘法时列竖式进行计算的方法， 只要写出模拟这一过程的程序，就能实现任意大整数的乘法运算。 经过查阅资料，找到一种更易于编程的方法， 即“列表法”。
用分治法实现两个二进制数的大整数乘法（带界面）
10-31
大整数分解问题：给定两个n位长二进制数x和y，求这两个数的乘积。时间复杂性控制在Θ(n1.6)
C语言实现大数整数乘法
shitouwoai的专栏
09-17 1862
/*大数整数乘法方法*/ #include #include #include char * bigmuilty(char*muiltied,int len1,char *muilty,int len2)//muiltied 为被乘数，len1为其长。muilty为乘数，len2为其长 {    int len;    int i=0;    int j=0;    int k=
大整数乘法，Java实现
aa792978017的博客
04-19 2760
/** * 分治法 */ public class BigDecimal { // 以字符串的方式输入两个超大的整数，将两个数值相乘的结果计算出来 public static void main(String[] args) { Scanner in = new Scanner(System.in); String a = in.next();...
用分治算法编程实现两个n位十进制大整数的乘法运算
u012577528的专栏
04-16 8685
首先在这里声明，请原谅我，各位伙计，我的大整数乘法并不是真正意义的大整数乘法，因为采用了int保存，并且对位数还有限制，必须实2的幂(2位4位能正常计算)。没有 实现负数的运算。本程序采用Java语言实现（比较好处理字符串），如果想要实现负数的话可以先将符号位提取，判断结果是正还是负，最后在连接两个正数相乘的结果。我 将提取正负号的代码注释了。 原理如下，时间复杂度为O(nlog3) =
算法---两个大整数相乘
充实喜乐
05-02 2762
所谓大整数的运算就是这些整数运算起来超过了int，double的存储范围 我们把它转化为字符串，因为字符串的长度是没有限制的
Python 实现大整数乘法算法的示例代码
12-31
今天，我们来介绍一种时间复杂度为 O (n ^ log 3) 的大整数乘法(log 表示以 2 为底的对数)。 介绍原理 karatsuba 算法要求乘数与被乘数要满足以下几个条件，第一，乘数与被乘数的位数相同；第二，乘数与被乘数的...
C++实现大整数乘法
08-25
C++实现大整数乘法 在计算机科学中，大整数乘法是指对两个大整数进行乘法运算的过程。由于大整数的存在，普通的整数乘法算法无法满足要求，因此需要专门设计大整数乘法算法。在C++中实现大整数乘法可以使用笛卡尔相...
C++实现大整数乘法（字符串乘法）
08-25
"C++实现大整数乘法（字符串乘法）" 本文主要介绍了C++实现大整数乘法（字符串乘法）的方法和实现代码，旨在帮助读者了解大整数乘法的实现原理和方法。 大整数乘法的概念 大整数乘法是指对两个大整数进行乘法运算...
Java实现大整数乘法
南蛮滴犊的博客
11-17 4884
请设计一个有效的算法，可以进行两个n位大整数的乘法运算 1 最暴力的方法：O(n^2) 2 我们采用分而治之的思想 将X和Y按如下方法分成两部分 那么 X = A*10^(n/2) + B Y = C*10^(n/2) + D X*Y = (A*10^(n/2) + B)*( C*10^(n/2) + D) = A*C*10^n + A...
算法与设计经典题：大整数乘法（教材2-4）
nanaz11的博客
09-09 7310
给定两个整数u和v，他们分别有m和n为数字，且m≤n，用通常的乘法求uv的值需要O(mn)时间，可以将u和v均看作是有n位数字的大整数，用本章介绍的分治法，在O（n^(log3)）时间内计算uv的值，当m&lt;&lt;n时，此法效率不高。设计算法在O（nlog2/3）时间计算uv的值 在O(n^(log3))时间内计算，把u，v分成两段，如分治法书中内容 uv=AC2^(n）+(（A-B）（...
大整数乘法实现思路
是时候开始写写博客了，Let's go...
07-03 9914
1、大整数乘法的实现思路（一）：模拟手工列竖式计算两个大整数的乘积 模拟手工计算两个整数相乘的过程：逐位相乘，错位累加，最后进位。以1235789×64523511235789×64523511235789\times6452351为例： 相乘的前提： 被乘数位数 &gt;= 乘数位数。x×yx×yx\times y的逐位相乘次数取决于乘数y的位数。 低位补0：乘数y从十位数开始乘以被乘数...
华为OJ机试题目：两个大整数相乘(纯C语言实现两个大整数相乘，两种方法实现大数相乘)
zy1049677338的博客
09-04 3086
题目描述： 输出两个不超过100位的大整数的乘积。 输入： 输入两个大整数，如1234567 123 输出： 输出乘积，如：151851741 样例输入： 1234567 123 样例输出： 151851741 &nbsp; 注意：在oj上不能直接套用我的代码，需要将无关的输出去除才行 方法一 思路： 解这道题目最简单的方法就是模拟我们笔算乘...
c语言用分治法计算两个整数的乘法,用分治算法编程实现两个n位十进制大整数的乘法运算...
weixin_42394206的博客
05-19 1962
首先在这里声明，请原谅我，各位伙计，我的大整数乘法并不是真正意义的大整数乘法，因为采用了int保存，并且对位数还有限制，必须实2的幂(2位4位能正常计算)。没有实现负数的运算。本程序采用Java语言实现(比较好处理字符串)，如果想要实现负数的话可以先将符号位提取，判断结果是正还是负，最后在连接两个正数相乘的结果。我将提取正负号的代码注释了。原理如下，时间复杂度为O(nlog3) = O(n1.59...
【C＋＋】六个默认成员函数(下)
最新发布
tangsl1552的博客
09-07 1069
本文介绍了C++运算符重载的核心概念。运算符重载通过定义特殊函数（如operator+）为类类型对象赋予运算能力，需遵循特定规则：函数名以operator开头、必须包含类类型参数、不能改变内置运算符含义。重点讲解了流插入/提取运算符（<<、>>）的全局重载方法，需配合友元函数访问私有成员；详细分析了赋值运算符重载的参数传递、返回值优化和自赋值检查；区分了拷贝构造与赋值重载的使用场景；还介绍了const成员函数对this指针的修饰作用，以及取地址运算符重载的注意事项。编译器会为未显式定
【C++高阶八】哈希的应用—位图和布隆过滤器
2201_75570391的博客
09-04 1382
哈希最常用的应用是unordered系列的容器，但是当面对海量数据，如：如果要使用unordered_set来解决40亿个整数，一个整数占4四节，总共大约占16个G的内存空间，并且set容器中不止有整型数据还有其他的数据，所以需要另一种解决方法，而一个数在或不在可以用1/0来表示，也就是说只需要一个比特位就可以知道一个数在不在其中，于此诞生了位图位图就是用每一位来存放某种状态，适用于海量数据且数据无重复的场景，通常是用来判断某个数据存不存在的。
C语言数组
2401_87837211的博客
09-07 475
本文主要学习数组
大整数乘法算法实现
"大整数乘法的实现代码示例" 大整数乘法是计算超过常规整型范围的大整数相乘的问题。在计算机科学中，特别是在算法和加密领域，处理大整数是非常常见的需求。这篇内容提供了一个C++语言实现大整数乘法的代码示例。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值