❶ 如何实现两个超大整数的相乘
*函数名称： 大数乘法
*函数过程：1 输入两个大数作为字符串
* 2 作一个双向链表
* 3 两个指针分别指向数字字符串的最低位
* 4 以第一个数的最低的一个位乘以第二个数的所有项存于链表中
* 5 链表首指针移
* 6 重复4，5依次从最低位乘到最高位
* 7 乘完后因为最低位是链表首，最后一位是链表尾。所以在逆顺输出链表。
* 4 直到循环结束
*入口参数：numa，numb，result字符串
*出口参数：无
*--------------------------------------------------------------------------*/
void multiply(char *numa, char *numb ,char *result)//用来储结果的)//计算乘积
{
char *pna = findend(numa);//指向numa的一个指针。point numa pna 指向乘数的最低位，
char *pnb = findend(numb);//指向numb的一个指针 //pnb 指向被乘数的最低位，
int along=(int)strlen(numa);//标记数字a的长度；
int blong=(int)strlen(numb);//标记数字b的长度；
int carry=0,temp_result;//存贮进位 和临时结果的
Node *head, // 用于存贮头指针
*pstart, // 用于存贮计算时的首指针
*pnew, //作于申请新结点
*pgo; //作为每计算完一行时，回到下一行起始节点用,移位标致来用
head = pstart =new Node;//初始化首结点和头结点。
pstart -> data = 0;
pstart -> next = NULL;
pstart -> ahead = NULL;
while (along--)
{
pgo = pstart;//保存进位点
blong = (int)strlen(numb);//初始化长度
pnb = findend(numb); //初始化指针
while ((blong-- && (blong>=0))|| carry != 0)
{
if(!pstart->next)//如果当前为空结点，则申请新结点
{
pnew = new Node;
pnew -> data = 0;
pnew -> next = NULL;
pnew -> ahead = pstart;
pstart -> next = pnew;
}
if(blong<0)temp_result = carry ;//处理只有进位的情况
else temp_result =(pstart->data+(*pna-48)*(*pnb-48)+carry);//自身值+新值+进位作为新值
pstart -> data = temp_result%10; //存贮个位
carry = temp_result/10; //存贮进位
pstart = pstart -> next; //结点移动
pnb--; //指针移向被乘数高位
}
pstart = pgo->next; //前进一个位置；
pna--; //指针移向乘数高位
}
pstart =head;//寻找链表的结尾点
while(pstart->next != 0)
{
pstart->data += 48;//!!<<<因为我们的输出是字符。所以再此加上48>>>> 逆顺输出
pstart = pstart->next ;
}
int tip = 0;//转为字符串用
pstart = pstart->ahead ;//找有效字
while(pstart != 0)//输出正序的结果；
{
result[tip++] = pstart->data;
pstart = pstart->ahead ;
}
result[tip] = '\0';
pstart =head; //释放空间
while(pstart->next != 0)
{
pnew = pstart->next ;delete pstart;
pstart =pnew;
}
return ;
}
❷ 求高手帮忙——大整数乘法的算法
就是高精度乘
模拟小学时学乘法竖式的方法
比如123*456
首先用一个数组a保存123
a[0]=1;a[1]=2;a[2]=3;
再用另外一个数组b保存456
b[0]=4;b[1]=5;b[2]=6;
做三次高精乘单精，如下：
a乘以b[0]，得到c0数组为
c0[0]=a[0]*b[0]=4
c0[1]=a[1]*b[0]=8
c0[2]=a[2]*b[0]=12
a乘以b[1]，得到c1数组为
c1[0]=a[0]*b[1]=5
c1[1]=a[1]*b[1]=10
c1[2]=a[2]*b[1]=15
同理，a乘以b[2]，得到c2数组为
c2[0]=6
c2[1]=12
c2[2]=18
下一步，是c0c1c2三个数组，依次移位相加，得到数组d，如下：
c0[0]c0[1]c0[2]
______c1[0]c1[1]c1[2]
____________c2[0]c2[1]c2[2]
--------------------------------
_d[0]d[1]d[2]d[3]d[4]
_413282718
最后一步，是对d数组的整理啦
从个位开始，每一位，如果大于9，则求模，前一位进位
for(i=4;i>0;i--)
__if(d[i]>9)
__{
____d[i-1]+=d[i]/10;
____d[i]=d[i]%10;
__}
经过整理，数组d各元素如下：
d[0]d[1]d[2]d[3]d[4]
56088
因此，依次输出，得到56088
123*456=56088
大数相乘亦此道理也~
❸ 大数乘法的几种算法分析及比较
1、分治乘法（最简单的是Karatsuba乘法，一般化以后有Toom-Cook乘法）；
2、快速傅里叶变换FFT(为了避免精度问题，可以改用快速数论变换FNTT)，时间复杂度O(NlgNlglgN)；
3、中国剩余定理（把每个数分解到一些互素的模上，然后每个同余方程对应乘起来就行）；
4、刚看到一个比FFT还快的算法Furer's algorithm，不过好像不太实用。下面的reference[3]给出了
❹ c语言大整数乘法
dc这个函数里面连b这个参数都没有使用，这也能出结果...，
if(z[0]='0')continue 也写错了
不是打击你，你的代码太滥了，实在不想去找错误，给你我以前写的代码吧，你自己整理一下
#include <stdio.h>
int mulx(char * a,int b,char * r,int d);
void init(char * s);
char buf1[4*1024];
char buf2[4*1024];
char buf3[4*1024];
int main()
{
char * a;
char * b;
char * r;
char * t;
int d;
int i;
a = buf1;
b = buf2;
r = buf3;
init(NULL);
while(scanf("%s %d",a,&d)!=EOF)
{
mulx(a,d,r,10);
printf("%s\n",r);
}
return 0;
}
char c2d[256]; //字符转换成数字
char * charset; //代表数字的字符
/*功能：设置使用那些字符表示数字，默认的为"0123456789ABCDEF"*/
/*参数：*/
/*返回值：*/
void init(char * s)
{
int i;
if(s==NULL)
charset = "0123456789ABCDEF";
else
charset = s;
for(i=0;i<256;i++)
c2d[i] = 0;
for(i=0;charset[i];i++)
c2d[charset[i]] = i;
}
/*功能：清除前导零*/
/*参数：需要清楚的数字*/
/*返回值：清零后数字的位数*/
int clearZeros(char * a)
{
int i,j;
for(i=0;a[i]==charset[0];i++);
for(j=0;a[i];i++,j++)
a[j] = a[i];
a[j] = 0;
if(j==0)
{
a[j++] = charset[0];
a[j] = 0;
}
return j;
}
/*功能：乘,用于进制转换之类*/
/*参数：a 和 b 分别为乘数，结果保存到 r , d 为使用的进制*/
/*注意：r 可以等于 a , b一定要小于d, 如果被乘数有前导0 则结果也会有前导0*/
/*返回值：结果的位数*/
int mulx(char * a,int b,char * r,int d)
{
int i,j,k,len;
int c,t;
if(r==NULL)
r = a;
for(i=0;a[i];i++);
len = k = i;
for(c=0,i--,r[k--]=0;i>=0 ;i--,k--)
{
t = c2d[a[i]] * b + c ;
c = t/d;
r[k] = charset[t%d];
}
if(c)
{
for(i=len,j=++len;i>=0;i--,j--)
r[j] = r[i];
r[0]=charset[c];
}
return len;
}
❺ 大数相乘 快速算法
给你一个吧
速度还可以
自己读下代码
/**************************************
算法复杂度为：O(longhta*longthb）
longtha为乘数的位数
longhtb为被乘数的位数
***************************************/
#include <stdio.h>
#include <string.h>
#include <conio.h>
#define LEN 1000
void mult(char [],char [],char []);
main()
{
char op1[LEN],op2[LEN],op3[LEN*2-1];
scanf("%s%s",op1,op2);
mult(op1,op2,op3);
printf("%s\n",op3);
getch();
return 0;
}
void reverse(char a[])
{
int longth=strlen(a);
int i;
for(i=0;i<longth/2;i++){
char t;
t=a[i];
a[i]=a[longth-i-1];
a[longth-i-1]=t;
}
}
void mult(char op1[LEN],char op2[LEN],char ans[LEN*2-1])
{
char top1[LEN];
char top2[LEN];
strcpy(top1,op1);
strcpy(top2,op2);
reverse(top1);
reverse(top2);
int k;
int top1s=strlen(top1);
int top2s=strlen(top2);
for(k=0;k<top1s+top2s;k++){
ans[k]='0';
}
int i,j;
int jw,ys;
int longth;
for(j=0;j<top2s;j++){
jw=0;
for(i=0;i<top1s;i++){
ys=((top1[i]-'0')*(top2[j]-'0')+jw+ans[i+j]-'0')%10;
jw=((top1[i]-'0')*(top2[j]-'0')+jw+ans[i+j]-'0')/10;
ans[i+j]=ys+'0';
}
if(jw>0){
ans[i+j]=jw+'0';
}
}
longth=i+j-1;
if(jw>0)
ans[longth++]=jw+'0';
ans[longth]='\0';
reverse(ans);
}