链表问题3——大整数相乘

Description

求两个不超过200位的非负整数的积。

解决方法：先考虑大整数存储结构，数组和链表都可以，因为数组使用不熟练，我先考虑链表，做了6小时才写好...也是醉了。下面简单介绍我的思路：

1、考虑链表的数据结构：先思考得知，链表结点要有pre、next指针，所以是双向链表，要设置头尾节点，我是让尾结点指向最后一个结点，头节点为虚结点。

2、链表构造问题：从输入的字符串转换为整型的链表

3、相乘：为了错位相加中运算方便，我将结果倒序表示，头节点后面连结果的最后一位数。一开始结果链表result为空，所以创建结点；用2个结点指针控制错位相加，注意进位的问题，在两个地方可能会进位：乘法运算并加上进位得到结果时和错位相加时。

代码有些复杂，但是一次AC

#include<iostream>
#include<cstring>
using namespace std;

class bigIntNode
{
public:
    int data;
    bigIntNode* pre;
    bigIntNode* next;
};
class bigInt
{

public:
    bigIntNode *head;
    bigIntNode *rear;
    int len;
    bigInt(){
        head = new bigIntNode();//虚的
        rear = head;//指向最后一个
    }
    ~bigInt(){
        bigIntNode *tmp=rear;
        while(head != tmp)
        {
            rear=tmp;
            delete rear;
            tmp=tmp->pre;
        }
        delete head;
    }
    void create(string a){//尾插
        const char *b = a.c_str();
        for(int i=0;i<strlen(b);i++){
            bigIntNode *newNode=new bigIntNode();
            newNode->data=b[i]-48;
            newNode->pre=rear;
            newNode->next =NULL;
            rear->next = newNode;
            rear=newNode;
        }
    }
    int add(bigIntNode* tmp,int val){
         if(tmp == NULL){
            create(val);
         }
         else{
           tmp->data+=val;
           if(tmp->data >=10){
                int j=tmp->data/10;
                tmp->data = tmp->data %10;
                return j;
           }
         }
         return 0;
    }
    void create(int a){//插入一个结点
        bigIntNode *newNode=new bigIntNode();
        newNode->data=a;
        newNode->pre=rear;
        newNode->next =NULL;
        rear->next = newNode;
        rear=newNode;
    }
    void print(){
        bigIntNode *tmp=rear;
        while(tmp != head){
            cout<<tmp->data;
            tmp=tmp->pre;
        }
        cout<<endl;
    }
    void multiply(bigInt &b){
        bigInt result;
        int full=0;
        bigIntNode *cur=result.head;//错位相加
        for(bigIntNode *r2=b.rear;r2 != b.head;r2=r2->pre){
            bigIntNode *tmp=cur;//具体实现每位加法
            for(bigIntNode *r1=rear;r1 != head;r1=r1->pre){
                full += r2->data*r1->data;
                full = result.add(tmp->next,full%10) + full/10;//考虑两种情况
                tmp=tmp->next;

            }
            cur=cur->next;
            if(full != 0) result.create(full);
            full =0;
        }
        result.print();

    }

};

int main()
{
    string a;
    getline(cin,a);
    bigInt tmp1;
    tmp1.create(a);

    getline(cin,a);
    bigInt tmp2;
    tmp2.create(a);

    tmp1.multiply(tmp2);

    return 0;
}

　　 然而，看到数组的实现方法...心情沉重.....

思路：和链表是差不多的，也是逆序

#include <stdio.h>
char strnum1[210], strnum2[210];
int num1[210], num2[210], ans[40000];//最大40000位
int main(){
	gets(strnum1);
	gets(strnum2);
	int m = 0, n = 0;//记录两个大整数长度

	//将字符串转化为数字
	while (strnum1[m]){
		num1[m] = strnum1[m] - ‘0‘;
		m++;
	}
	while (strnum2[n]){
		num2[n] = strnum2[n] - ‘0‘;
		n++;
	}
	int up; //进位
	int tmp ; //临时变量
	int k, p, i, j; // k,p 记录计算的位置
	for (i = m - 1, k = 0; i >= 0; i--, k++){
		tmp = 0, up = 0;
		for (j = n - 1, p = 0; j >= 0; j--, p++){
			tmp = num1[i] * num2[j] + up + ans[k + p];//直接把所有结果一起相加
			ans[k + p] = tmp % 10;
			up = tmp / 10;
		}
		if (up > 0)
			ans[k + p] = up;
	}
	int len = m * n;
	while (ans[len--] == 0);//定位第一个非0起点
	//逆序输出
	for (int i = len + 1; i >= 0; i--)
		printf("%d", ans[i]);
	return 0;
}