链表实现的大整数乘法

#include<iostream>
#include<malloc.h>

using namespace std;

// linked list struct
typedef struct Node {
	char buffer;        // enter a char
	int integer;        // store integer
	int number = 0;     // record number
	struct Node* next;  // pointer to next
	Node(int elem) :integer(elem), next(NULL) {}
}*List;

// initialize the linked list
void init_list(List& L) {
	// reverse insert
	List p = new Node(0);
	L = new Node(0);
	// exclude starting with zero
	while (cin >> p->buffer) {
		if (p->buffer != '0') {
			break;
		}
	}
	while (p->buffer >= '0' && p->buffer <= '9') {
		p->integer = p->buffer - '0';
		p->next = L->next;
		L->next = p;
		L->number++;
		p = new Node(0);
		cin >> p->buffer;
	}
}

// insert a single node
void insert_node(List& L, int elem) {
	List p = new Node(0);
	p->integer = elem;
	p->next = L->next;
	L->next = p;
}

// reverse linked list
void reverse_list(List& L) {
	List p = new Node(0);
	List q = new Node(0);
	p = L->next;
	L->next = NULL;
	while (p) {
		q = p->next;
		p->next = L->next;
		L->next = p;
		p = q;
	}
}



// multiplication calculate
List calculate_multiplication(List L1, List L2) {
	if (L1->number < 1 || L2->number < 1) {
		List Temp = new Node(0);
		insert_node(Temp, 0);
		return Temp;
	}
	List p = new Node(0);
	List q = new Node(0);
	List q_1 = new Node(0);
	List multiplication = new Node(0);
	List multiplication_temp = new Node(0);
	List multiplication_alias = new Node(0);
	if (L1->number > L2->number) {
		reverse_list(L2);
		p = L2->next;
		p->number = L2->number;
		q = L1->next;
		q->number = L1->number;
	}
	else {
		reverse_list(L1);
		p = L1->next;
		p->number = L1->number;
		q = L2->next;
		q->number = L2->number;
	}
	//reverse_list(q);
	q_1 = q;
	int list_total_number = p->number + q->number - 1;
	for (int i = 0; i < list_total_number; i++) {
		insert_node(multiplication, 0);
	}
	multiplication_alias = multiplication->next;
	int k = 1;
	while (p) {
		int remeber = k;
		while (q_1) {
			insert_node(multiplication_temp, (p->integer * q_1->integer));
			q_1 = q_1->next;
		}
		while (remeber - 1) {
			multiplication_alias = multiplication_alias->next;
			remeber--;
		}
		while (multiplication_temp->next) {
			multiplication_alias->integer += multiplication_temp->next->integer;
			multiplication_alias = multiplication_alias->next;
			multiplication_temp = multiplication_temp->next;
		}
		k++;
		q_1 = NULL;
		q_1 = q;
		p = p->next;
		multiplication_alias = NULL;
		multiplication_alias = multiplication->next;
		multiplication_temp = new Node(0);
	}
	// now let's work on the results
	reverse_list(multiplication);
	multiplication_temp = new Node(0);
	multiplication_temp = multiplication->next;
	int temp = 0;
	while (multiplication_temp) {
		if (multiplication_temp) {
			int swap = multiplication_temp->integer + temp;
			multiplication_temp->integer = (multiplication_temp->integer + temp) % 10;
			temp = swap / 10;
		}
		multiplication_temp = multiplication_temp->next;
	}
	if (temp) {
		reverse_list(multiplication);
		insert_node(multiplication, temp);
		reverse_list(multiplication);
	}
	reverse_list(multiplication);
	return multiplication;
}


// print linked list 
void print_list(List L) {
	while (L->next) {
		cout << L->next->integer;
		L = L->next;
	}
}

int main() {
	while (1) {
		List L1, L2;
		init_list(L1);
		init_list(L2);
		print_list(calculate_multiplication(L1, L2));
		cout << endl;
		delete L1;
		delete L2;
		L1 = NULL;
		L2 = NULL;
	}
	return 0;
}