长整数加减法运算

已于 2023-12-28 23:48:37 修改
阅读量2.6k 收藏 40
点赞数 7
文章标签： 长整数 双向循环链表 加法运算 减法运算 输入检查
于 2021-11-27 16:12:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36833548/article/details/121578979
版权

长整数加减法运算

【问题描述】

设计一个实现任意长的整数进行加法和减法运算的演示程序。
【基本要求】

利用双向循环链表实现长整数的存储，每个结点含一个整型变量。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。

【测试数据】

(1)0；0；应输出“0”。

(2)-2345,6789；-7654,3211；应输出“-1,0000,0000”。

(3)-9999,9999；1,0000,0000,0000；应输出“9999,0000,0001”

(4)1,0001,0001；-1,0001,0001；应输出“0”。

(5)1,0001,0001；-1,0001,0000；应输出“1”。

(6)-9999,9999,9999；-9999,9999,9999；应输出“-1,9999,9999,9998”。

(7)1,0000,9999,9999；1；应输出“1,0001,0000,0000”。

【实现提示】

(1)可以在每个结点中仅存十进制的4位，即不超过9999的非负整数。

(2)可以利用头结点数据域的符号代表长整数的符号。用其绝对值表示元素结点数目。相加过程中不要破坏两个操作数链表。不能给长整数位数规定上限。

结点定义

template<class T>
struct LinkNode
{
	T data;
	LinkNode<T>* Leftlink;
	LinkNode<T>* Rightlink;
	LinkNode()
	{
		data = 0;
		Leftlink = NULL;
		Rightlink = NULL;
	}
	LinkNode(T x)
	{
		data = x;
		Leftlink = NULL;
		Rightlink = NULL;
	}
};

双向循环链表函数定义

template<class T>
class CircLinkList
{
public:
	CircLinkList();//构造函数
	CircLinkList(T x);//含参构造函数
	~CircLinkList();//析构函数
	bool Insert(T x);//插入结点
	LinkNode<T>* Get_head();//取头结点
	void Make_Empty();//清空链表
private:
	LinkNode<T>* head;
};

构造函数

template<class T>
CircLinkList<T>::CircLinkList()
{
	head = new LinkNode<T>;
	head->Leftlink = head;
	head->Rightlink = head;
}

template<class T>
CircLinkList<T>::CircLinkList(T x)
{
	head = new LinkNode<T>(x);
	head->Leftlink = head;
	head->Rightlink = head;
}

析构函数

template<class T>
CircLinkList<T>::~CircLinkList()
{
	Make_Empty();
}

插入结点

template<class T>
bool CircLinkList<T>::Insert(T x)
{
	LinkNode<T>* newnode, * current = head;
	newnode = new LinkNode<T>(x);
	if (newnode == NULL)
	{
		cout << "内存不足" << endl;
		return false;
	}
	while (1)
	{
		if (current->Rightlink == head)
		{
			newnode->Rightlink = current->Rightlink;
			current->Rightlink = newnode;
			newnode->Leftlink = current;
			current = current->Rightlink;
			current->Rightlink->Leftlink = newnode;
			break;
		}
		current = current->Rightlink;
	}
	return true;
}

取头结点

template<class T>
LinkNode<T>* CircLinkList<T>::Get_head()
{
	return head;
}

清空链表

template<class T>
void CircLinkList<T>::Make_Empty()
{
	LinkNode<T>* current = head->Rightlink, * p = NULL;
	while (current != head)
	{
		p = current;
		current = current->Rightlink;
		delete p;
		p = NULL;
	}
	current = NULL;
	delete head;
	head = NULL;
}

自定义函数

void Input(string& a,string& b);//输入函数
bool Check_Input(const string& t);//检查输入是否合法
void Calctor(string a, string b);//加减法计算器
void Check_count(int& n, string a);//头结点数据域赋值
void All_int_IN(string a, CircLinkList<int>& t);//长整数插入链表
void Add_int(LinkNode<int>* Lhead, LinkNode<int>* Rhead);//加法运算
void Sub_int(LinkNode<int>* Lhead, LinkNode<int>* Rhead);//减法运算
void Output(LinkNode<int>* t);//输出函数
void Delete_result(LinkNode<int>* t);//删除运算结果

输入函数

void Input(string& a, string& b)
{
	cout << "来自UJN_Zgq的长整数加减法计算器" << endl;
	cout << "请输入第一个长整数:(合法输入格式:1,0001,0001)" << endl;
    L1:	cin >> a;
	if (!Check_Input(a))
	{
		a = "";
		cout << "输入非法!!!" << endl;
		cout << "请重新输入第一个长整数:(合法输入格式:1,0001,0001)" << endl;
		goto L1;
	}
	cout << "请输入第二个长整数:(合法输入格式:1,0001,0001)" << endl;
	L2:	cin >> b;
	if (!Check_Input(b))
	{
		b = "";
		cout << "输入非法!!!" << endl;
		cout << "请重新输入第二个长整数:(合法输入格式:1,0001,0001)" << endl;
		goto L2;
	}
}

检查输入合法

bool Check_Input(const string& t)
{
	int len = t.length();
	char flag = ',';
	int p = 0;
	int i = 0;
	if (t[0] == '-')
		i = 1;
	while (p != -1 || i < len)
	{
		int num = 0;
		p = t.find(flag, i);
		if (p == -1)
		{
			num = stoi(t.substr(i, len - i));
			if (num < 0 || num>9999)
				return false;
			i = len;
		}
		else
		{
			num = stoi(t.substr(i, p - i));
			if (num < 0 || num>9999)
				return false;
			i = p + 1;
		}
	}
	return true;
}

加减法计算器

void Calctor(string a, string b)
{
	int coount1 = 0, count2 = 0, left = 0, right = 0;
	Check_count(coount1, a);
	Check_count(count2, b);
	CircLinkList<int> Left_num(coount1), Right_num(count2);
	LinkNode<int>* Left_head = NULL, *Right_head = NULL;
	Left_head = Left_num.Get_head();
	Right_head = Right_num.Get_head();
	All_int_IN(a,Left_num);
	All_int_IN(b, Right_num);
	cout << "加法结果输出:" << endl;
	Add_int(Left_head, Right_head);
	cout << "减法结果输出:" << endl;
	Right_head->data = -Right_head->data;
	Sub_int(Left_head, Right_head);
	Right_head->data = -Right_head->data;
}

头结点数据域赋值

void Check_count(int& n, string a)
{
	int len = a.length();
	for (int i = 0; i < len; i++)
	{
		if (isdigit(a[i]))
		{
			n++;
		}
	}
	if (a[0] == '-')
		n = -n;
}

长整数插入链表

void All_int_IN(string a, CircLinkList<int>& t)
{
	int len = a.length();
	char flag = ',';
	int p = 0;
	int i = 0;
	while (p != -1 || i < len)
	{
		int num = 0;
		p = a.find(flag, i);
		if (p == -1)
		{
			num = stoi(a.substr(i, len-i));
			if (num < 0)
				num = -num;
			t.Insert(num);
			i = len;
		}
		else
		{
			num = stoi(a.substr(i, p-i));
			if (num < 0)
				num = -num;
			t.Insert(num);
			i = p + 1;
		}
	}
}

加法运算

void Add_int(LinkNode<int>* Lhead, LinkNode<int>* Rhead)
{
	int num = 0;
	LinkNode<int>* result=NULL;
	result = new LinkNode<int>;
	if (result == NULL)
		return;
	LinkNode<int>* Left = Lhead, * Right = Rhead;
	if (Left->data > 0 && Right->data > 0 || Left->data < 0 && Right->data < 0)
	{
		int flag = 0;
		if (Left->data > 0)
		{
			result->data = 1;
		}
		else
		{
			result->data = -1;
		}
		Left = Left->Leftlink;
		Right = Right->Leftlink;
		while (Left != Lhead || Right != Rhead || flag == 1)
		{
			LinkNode<int>* newnode;
			if (Right == Rhead || Left == Lhead)
			{
				if (Left == Lhead && Right == Rhead)
							num = 0 + 0 + flag;
				else
				{
					if (Right == Rhead)
						num = Left->data + 0 + flag;
					else
					{
						if (Left == Lhead)
						num = 0 + flag + Right->data;
					}
				}
			}
			else
			{
				num = Left->data + Right->data + flag;
			}
			flag = 0;
			if (num > 9999)
			{
				num -= 10000;
				flag = 1;
			}
			if (Left != Lhead)
				Left = Left->Leftlink;
			if (Right != Rhead)
				Right = Right->Leftlink;
			newnode = new LinkNode<int>(num);
			newnode->Rightlink = result->Rightlink;
			result->Rightlink = newnode;
		}
		Output(result);
		Delete_result(result);
	}
	else
	{
		Sub_int(Lhead, Rhead);
	}
}

减法运算

void Sub_int(LinkNode<int>* Lhead, LinkNode<int>* Rhead)
{
	LinkNode<int>* Left = Lhead, * Right = Rhead;
	LinkNode<int>* result = NULL;
	result = new LinkNode<int>;
	if (result == NULL)
		return;
	if (Left->data > 0 && Right->data < 0 || Left->data < 0 && Right->data > 0)
	{
		int flag = 0;
		if (abs(Left->data) > abs(Right->data))
		{
			if (Left->data < 0)
				result->data = -1;
			else
				result->data = 1;
			Left = Left->Leftlink;
			Right = Right->Leftlink;
			while (Left != Lhead)
			{
				LinkNode<int>* newnode = NULL;
				int num = 0;
				if (Right != Rhead)
					num = Left->data - Right->data - flag;
				else
					num = Left->data - 0 - flag;
				flag = 0;
				if (num < 0)
				{
					flag = 1;
					num += 10000;
				}
				if (Right != Rhead)
					Right = Right->Leftlink;
				Left = Left->Leftlink;
				newnode = new LinkNode<int>(num);
				newnode->Rightlink = result->Rightlink;
				result->Rightlink = newnode;
			}
		}
		else
		{
			if (abs(Left->data) < abs(Right->data))
			{
				if (Right->data < 0)
					result->data = -1;
				else
					result->data = 1;
				Left = Left->Leftlink;
				Right = Right->Leftlink;
				while (Right != Rhead )
				{
					LinkNode<int>* newnode = NULL;
					int num = 0;
					if (Left != Lhead)
						num = Right->data - Left->data - flag;
					else
						num = Right->data - 0 - flag;
					flag = 0;
					if (num < 0)
					{
						flag = 1;
						num += 10000;
					}
					if (Left != Lhead)
						Left = Left->Leftlink;
					Right = Right->Leftlink;
					newnode = new LinkNode<int>(num);
					newnode->Rightlink = result->Rightlink;
					result->Rightlink = newnode;
				}
			}
			else
			{
				if (Left->data < 0)
				{
					int flag = 0;
					Left = Left->Leftlink;
					Right = Right->Leftlink;
					while (Left != Lhead && Right != Rhead)
					{
						LinkNode<int>* newnode = NULL;
						int num = 0;
						num = Right->data - Left->data - flag;
						if (num < 0)
						{
							if (Right->Leftlink != Rhead)
							{
								flag = 1;
								num += 10000;
							}
						}
						if (Right != Rhead)
							Right = Right->Leftlink;
						if (Left != Lhead)
							Left = Left->Leftlink;
						if (Right == Rhead && Left == Lhead)
						{
							if (num < 0)
								result->data = -1;
							else
								result->data = 1;
						}
						newnode = new LinkNode<int>(num);
						newnode->Rightlink = result->Rightlink;
						result->Rightlink = newnode;
					}
				}
				else
				{
					int flag = 0;
					Left = Left->Leftlink;
					Right = Right->Leftlink;
					while (Left != Lhead && Right != Rhead)
					{
						LinkNode<int>* newnode = NULL;
						int num = 0;
						num = Left->data - Right->data - flag;
						if (num < 0)
						{
							if (Left->Leftlink != Lhead)
							{
								flag = 1;
								num += 10000;
							}
						}
						if (Right != Rhead)
							Right = Right->Leftlink;
						if (Left != Lhead)
							Left = Left->Leftlink;
						if (Right == Rhead && Left == Lhead)
						{
							if (num < 0)
								result->data = -1;
							else
								result->data = 1;
						}
						newnode = new LinkNode<int>(num);
						newnode->Rightlink = result->Rightlink;
						result->Rightlink = newnode;
					}
				}
			}
		}
		Output(result);
		Delete_result(result);
	}
	else
	{
		Add_int(Lhead, Rhead);
	}
}

输出函数

void Output(LinkNode<int>* t)
{
	int temp = 0;
	LinkNode<int>* current = t->Rightlink;
	while (current != NULL)
	{
		if (current->data == 0)
		{
			if (current->Rightlink == NULL)
				cout << current->data;
		}
		else
		{
			break;
		} 
		current = current->Rightlink;
	}
	if (current != NULL)
	{
		if (t->data < 0)
			cout << '-';
	}
	int flag = 1;
	while(current != NULL)
	{
		temp = current->data;
		if (flag == 0)
		{
			cout << temp / 1000 << temp / 100 % 10 << temp / 10 % 10 << temp % 10;
			flag = 0;
		}
		else
		{
			cout << current->data;
			flag = 0;
		}
		current = current->Rightlink;
		if (current != NULL)
			cout << ',';
	}
	cout << endl;
}

删除运算结果

void Delete_result(LinkNode<int>* t)
{
	LinkNode<int>* current = t;
	while (t != NULL)
	{
		t = t->Rightlink;
		delete current;
		current = t;
	}
}

主函数

int main()
{
	string a, b;
	Input(a, b);
	Calctor(a, b);
	return 0;
}

完整代码

#include<iostream>
#include<string>

using namespace std;

template<class T>
struct LinkNode
{
	T data;
	LinkNode<T>* Leftlink;
	LinkNode<T>* Rightlink;
	LinkNode()
	{
		data = 0;
		Leftlink = NULL;
		Rightlink = NULL;
	}
	LinkNode(T x)
	{
		data = x;
		Leftlink = NULL;
		Rightlink = NULL;
	}
};

template<class T>
class CircLinkList
{
public:
	CircLinkList();//构造函数
	CircLinkList(T x);//含参构造函数
	~CircLinkList();//析构函数
	bool Insert(T x);//插入结点
	LinkNode<T>* Get_head();//取头结点
	void Make_Empty();//清空链表
private:
	LinkNode<T>* head;
};

template<class T>
CircLinkList<T>::CircLinkList()
{
	head = new LinkNode<T>;
	head->Leftlink = head;
	head->Rightlink = head;
}

template<class T>
CircLinkList<T>::CircLinkList(T x)
{
	head = new LinkNode<T>(x);
	head->Leftlink = head;
	head->Rightlink = head;
}

template<class T>
CircLinkList<T>::~CircLinkList()
{
	Make_Empty();
}

template<class T>
bool CircLinkList<T>::Insert(T x)
{
	LinkNode<T>* newnode, * current = head;
	newnode = new LinkNode<T>(x);
	if (newnode == NULL)
	{
		cout << "内存不足" << endl;
		return false;
	}
	while (1)
	{
		if (current->Rightlink == head)
		{
			newnode->Rightlink = current->Rightlink;
			current->Rightlink = newnode;
			newnode->Leftlink = current;
			current = current->Rightlink;
			current->Rightlink->Leftlink = newnode;
			break;
		}
		current = current->Rightlink;
	}
	return true;
}

template<class T>
LinkNode<T>* CircLinkList<T>::Get_head()
{
	return head;
}

template<class T>
void CircLinkList<T>::Make_Empty()
{
	LinkNode<T>* current = head->Rightlink, * p = NULL;
	while (current != head)
	{
		p = current;
		current = current->Rightlink;
		delete p;
		p = NULL;
	}
	current = NULL;
	delete head;
	head = NULL;
}

void Input(string& a,string& b);//输入函数
bool Check_Input(const string& t);//检查输入是否合法
void Calctor(string a, string b);//加减法计算器
void Check_count(int& n, string a);//头结点数据域赋值
void All_int_IN(string a, CircLinkList<int>& t);//长整数插入链表
void Add_int(LinkNode<int>* Lhead, LinkNode<int>* Rhead);//加法运算
void Sub_int(LinkNode<int>* Lhead, LinkNode<int>* Rhead);//减法运算
void Output(LinkNode<int>* t);//输出函数
void Delete_result(LinkNode<int>* t);//删除运算结果

void All_int_IN(string a, CircLinkList<int>& t)
{
	int len = a.length();
	char flag = ',';
	int p = 0;
	int i = 0;
	while (p != -1 || i < len)
	{
		int num = 0;
		p = a.find(flag, i);
		if (p == -1)
		{
			num = stoi(a.substr(i, len-i));
			if (num < 0)
				num = -num;
			t.Insert(num);
			i = len;
		}
		else
		{
			num = stoi(a.substr(i, p-i));
			if (num < 0)
				num = -num;
			t.Insert(num);
			i = p + 1;
		}
	}
}

void Check_count(int& n, string a)
{
	int len = a.length();
	for (int i = 0; i < len; i++)
	{
		if (isdigit(a[i]))
		{
			n++;
		}
	}
	if (a[0] == '-')
		n = -n;
}

bool Check_Input(const string& t)
{
	int len = t.length();
	char flag = ',';
	int p = 0;
	int i = 0;
	if (t[0] == '-')
		i = 1;
	while (p != -1 || i < len)
	{
		int num = 0;
		p = t.find(flag, i);
		if (p == -1)
		{
			num = stoi(t.substr(i, len - i));
			if (num < 0 || num>9999)
				return false;
			i = len;
		}
		else
		{
			num = stoi(t.substr(i, p - i));
			if (num < 0 || num>9999)
				return false;
			i = p + 1;
		}
	}
	return true;
}

void Output(LinkNode<int>* t)
{
	int temp = 0;
	LinkNode<int>* current = t->Rightlink;
	while (current != NULL)
	{
		if (current->data == 0)
		{
			if (current->Rightlink == NULL)
				cout << current->data;
		}
		else
		{
			break;
		} 
		current = current->Rightlink;
	}
	if (current != NULL)
	{
		if (t->data < 0)
			cout << '-';
	}
	int flag = 1;
	while(current != NULL)
	{
		temp = current->data;
		if (flag == 0)
		{
			cout << temp / 1000 << temp / 100 % 10 << temp / 10 % 10 << temp % 10;
			flag = 0;
		}
		else
		{
			cout << current->data;
			flag = 0;
		}
		current = current->Rightlink;
		if (current != NULL)
			cout << ',';
	}
	cout << endl;
}

void Input(string& a, string& b)
{
	cout << "来自UJN_Zgq的长整数加减法计算器" << endl;
	cout << "请输入第一个长整数:(合法输入格式:1,0001,0001)" << endl;
    L1:	cin >> a;
	if (!Check_Input(a))
	{
		a = "";
		cout << "输入非法!!!" << endl;
		cout << "请重新输入第一个长整数:(合法输入格式:1,0001,0001)" << endl;
		goto L1;
	}
	cout << "请输入第二个长整数:(合法输入格式:1,0001,0001)" << endl;
	L2:	cin >> b;
	if (!Check_Input(b))
	{
		b = "";
		cout << "输入非法!!!" << endl;
		cout << "请重新输入第二个长整数:(合法输入格式:1,0001,0001)" << endl;
		goto L2;
	}
}

void Add_int(LinkNode<int>* Lhead, LinkNode<int>* Rhead)
{
	int num = 0;
	LinkNode<int>* result=NULL;
	result = new LinkNode<int>;
	if (result == NULL)
		return;
	LinkNode<int>* Left = Lhead, * Right = Rhead;
	if (Left->data > 0 && Right->data > 0 || Left->data < 0 && Right->data < 0)
	{
		int flag = 0;
		if (Left->data > 0)
		{
			result->data = 1;
		}
		else
		{
			result->data = -1;
		}
		Left = Left->Leftlink;
		Right = Right->Leftlink;
		while (Left != Lhead || Right != Rhead || flag == 1)
		{
			LinkNode<int>* newnode;
			if (Right == Rhead || Left == Lhead)
			{
				if (Left == Lhead && Right == Rhead)
							num = 0 + 0 + flag;
				else
				{
					if (Right == Rhead)
						num = Left->data + 0 + flag;
					else
					{
						if (Left == Lhead)
						num = 0 + flag + Right->data;
					}
				}
			}
			else
			{
				num = Left->data + Right->data + flag;
			}
			flag = 0;
			if (num > 9999)
			{
				num -= 10000;
				flag = 1;
			}
			if (Left != Lhead)
				Left = Left->Leftlink;
			if (Right != Rhead)
				Right = Right->Leftlink;
			newnode = new LinkNode<int>(num);
			newnode->Rightlink = result->Rightlink;
			result->Rightlink = newnode;
		}
		Output(result);
		Delete_result(result);
	}
	else
	{
		Sub_int(Lhead, Rhead);
	}
}

void Sub_int(LinkNode<int>* Lhead, LinkNode<int>* Rhead)
{
	LinkNode<int>* Left = Lhead, * Right = Rhead;
	LinkNode<int>* result = NULL;
	result = new LinkNode<int>;
	if (result == NULL)
		return;
	if (Left->data > 0 && Right->data < 0 || Left->data < 0 && Right->data > 0)
	{
		int flag = 0;
		if (abs(Left->data) > abs(Right->data))
		{
			if (Left->data < 0)
				result->data = -1;
			else
				result->data = 1;
			Left = Left->Leftlink;
			Right = Right->Leftlink;
			while (Left != Lhead)
			{
				LinkNode<int>* newnode = NULL;
				int num = 0;
				if (Right != Rhead)
					num = Left->data - Right->data - flag;
				else
					num = Left->data - 0 - flag;
				flag = 0;
				if (num < 0)
				{
					flag = 1;
					num += 10000;
				}
				if (Right != Rhead)
					Right = Right->Leftlink;
				Left = Left->Leftlink;
				newnode = new LinkNode<int>(num);
				newnode->Rightlink = result->Rightlink;
				result->Rightlink = newnode;
			}
		}
		else
		{
			if (abs(Left->data) < abs(Right->data))
			{
				if (Right->data < 0)
					result->data = -1;
				else
					result->data = 1;
				Left = Left->Leftlink;
				Right = Right->Leftlink;
				while (Right != Rhead )
				{
					LinkNode<int>* newnode = NULL;
					int num = 0;
					if (Left != Lhead)
						num = Right->data - Left->data - flag;
					else
						num = Right->data - 0 - flag;
					flag = 0;
					if (num < 0)
					{
						flag = 1;
						num += 10000;
					}
					if (Left != Lhead)
						Left = Left->Leftlink;
					Right = Right->Leftlink;
					newnode = new LinkNode<int>(num);
					newnode->Rightlink = result->Rightlink;
					result->Rightlink = newnode;
				}
			}
			else
			{
				if (Left->data < 0)
				{
					int flag = 0;
					Left = Left->Leftlink;
					Right = Right->Leftlink;
					while (Left != Lhead && Right != Rhead)
					{
						LinkNode<int>* newnode = NULL;
						int num = 0;
						num = Right->data - Left->data - flag;
						if (num < 0)
						{
							if (Right->Leftlink != Rhead)
							{
								flag = 1;
								num += 10000;
							}
						}
						if (Right != Rhead)
							Right = Right->Leftlink;
						if (Left != Lhead)
							Left = Left->Leftlink;
						if (Right == Rhead && Left == Lhead)
						{
							if (num < 0)
								result->data = -1;
							else
								result->data = 1;
						}
						newnode = new LinkNode<int>(num);
						newnode->Rightlink = result->Rightlink;
						result->Rightlink = newnode;
					}
				}
				else
				{
					int flag = 0;
					Left = Left->Leftlink;
					Right = Right->Leftlink;
					while (Left != Lhead && Right != Rhead)
					{
						LinkNode<int>* newnode = NULL;
						int num = 0;
						num = Left->data - Right->data - flag;
						if (num < 0)
						{
							if (Left->Leftlink != Lhead)
							{
								flag = 1;
								num += 10000;
							}
						}
						if (Right != Rhead)
							Right = Right->Leftlink;
						if (Left != Lhead)
							Left = Left->Leftlink;
						if (Right == Rhead && Left == Lhead)
						{
							if (num < 0)
								result->data = -1;
							else
								result->data = 1;
						}
						newnode = new LinkNode<int>(num);
						newnode->Rightlink = result->Rightlink;
						result->Rightlink = newnode;
					}
				}
			}
		}
		Output(result);
		Delete_result(result);
	}
	else
	{
		Add_int(Lhead, Rhead);
	}
}

void Delete_result(LinkNode<int>* t)
{
	LinkNode<int>* current = t;
	while (t != NULL)
	{
		t = t->Rightlink;
		delete current;
		current = t;
	}
}

void Calctor(string a, string b)
{
	int coount1 = 0, count2 = 0, left = 0, right = 0;
	Check_count(coount1, a);
	Check_count(count2, b);
	CircLinkList<int> Left_num(coount1), Right_num(count2);
	LinkNode<int>* Left_head = NULL, *Right_head = NULL;
	Left_head = Left_num.Get_head();
	Right_head = Right_num.Get_head();
	All_int_IN(a,Left_num);
	All_int_IN(b, Right_num);
	cout << "加法结果输出:" << endl;
	Add_int(Left_head, Right_head);
	cout << "减法结果输出:" << endl;
	Right_head->data = -Right_head->data;
	Sub_int(Left_head, Right_head);
	Right_head->data = -Right_head->data;
}

int main()
{
	string a, b;
	Input(a, b);
	Calctor(a, b);
	return 0;
}
chn-zgq
关注
  • 7
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
超长整数的减法
2301_79816227的博客
03-03 371
输出只有一行，是长整数A减去长整数B的运算结果，从高到低依次输出各位数字。要求：若结果为0，则只输出一个0；否则输出的结果的最高位不能为0，并且各位数字紧密输出。相减时，没考虑到前面数字可能为零，要找到前面第一个非零数，才能开始进位。从键盘读入两个整数，要考虑输入高位可能为0的情况（如00083）。编写程序实现两个超长正整数（每个最长80位数字）的减法运算。输出的时候可能，没把字符转化成对应数字。首先使用gets函数读取两行整数。1. 第一行是超长正整数A；最后仿照手动计算进行计算。
【指针】第7关：超长整数的加减运算
[]
04-09 1012
【代码】【指针】第7关：超长整数的加减运算。
【实验笔记】C语言实验——超长正整数的减法运算
qq_45801887的博客
11-23 1万+
输出只有一行，是长整数A减去长整数B的运算结果，从高到低依次输出各位数字。要求: 若结果为0，则只输出一个0;否则输出的结果的最高位不能为0，并且各位数字紧密输出。题目要求为超长正整数的减法运算，容易知道整型变量无法完成此操作，所以大体思路：考虑用两个字符数组储存，用两数组的ASCII码进行运算，然后判断符号，进行输出。进行两个正整数减法运算，234098 - 134098703578230056 = - 134098703577995958。编写程序实现两个超长正整数(每个最长80位数字)的减法运算。
C++大整数的加减乘除
最新发布
weixin_42944928的博客
04-27 318
（注意，_string 你用C++ std::string 代替就行）大整数除法迅飞星火和文心一言给的算法可参考，但结果都不对。
超长整数的基础运算 算法实现之加、减篇
每个程序员都有梦想自己成为所在领域的神的权利
10-20 1219
由于大整数有正负之分，所以两个大整数相加有四种情况：a+b，a+（-b），（-a）+b和-a+（-b）。对于a+b和-a+(-b)，可以通过对数组对应位元素相加即可，主要是考虑进位问题。而a+（-b）和（-a）+b，其实就是两个大整数的减法，其主要考虑的问题是向高位借位的问题。所以减法可以通过加法的运算得到结果。
C++基础与深度解析 || 长整数加法
qq_36291615的博客
09-06 938
一个文件中包含两行数字序列，每行数字序列表示一个十进制长整数（只包含0~9与符号位，如果存在符号位，那么只能处于开头位置)。你的程序应当接收一个输入参数，表示该文件，程序读取这两个序列并求二者之和，将结果输入到屏幕上。需要注意的是，由于序列可能比较长，因此其对应的数值可能无法使用一个内建数据类型来保存。需要使用一个数组（或vector)来保存每一位的数值。
模拟：超大整数加减法
Belous的博客
05-16 643
无数次面对这样的问题，两个长度是几千甚至上万的字符串相加或相减，输出结果。这次专门练习写一遍。校赛ACM时候就卡在这种题上了，不然就能AC七道题了！！        1.两个大数相加的函数比相减的简单些，不用考虑结果会不会是负数的问题。接收到两个字符串和一个要存储和的目标字符串，先反转两个字符串，后以较长字符串为目标，挨个加到存储和的字符串。当当前长度小于短串的时候，每一位再加上短串的对应位，当前...
长整数加减法运算 双向链表
12-08
在计算机科学中，长整数加减法运算和双向链表是两个重要的概念，它们在数据处理和算法设计中有着广泛的应用。本文将详细探讨这两个主题，并结合它们在实际问题中的应用，帮助读者深入理解其原理和实现方法。 首先，...
长整数加减运算
01-03
本文将深入探讨如何利用链表数据结构来实现长整数的加法和减法运算。 首先，让我们理解什么是链表。链表是一种线性数据结构，其中的元素（节点）不连续存储在内存中，而是通过指针相互连接。每个节点包含两部分：...
线性表设计100位以内的长整数加减运算的程序
05-21
"线性表设计100位以内的长整数加减运算的程序" 知识点一：链表的基本结构和操作方法 在设计一个100位以内的长整数加减运算的程序时，使用链表来表示长整数是一个不错的选择。链表的基本结构包括节点和指针，节点中...
长整数四则运算加减法
07-18
1、本程序实现计算任意长的整数的加、减法运算. 以用户和计算机对话的方式，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令，然后程序就计算并显示出这两个数的运算。 2、本...
长整数加减
12-09
长整数加减，两数相加大于9向前一位进一，当最高位大于9则不进一，两数相加大于9向前一位进一，当最高位大于9则不进一
长整数运算.zip
10-31
[ 问题描述 ] 设计程序实现两个任意长整数的求和运算。 [ 基本要求 ] 《数据结构》题集 利用双向循环链表实现长整数的存储, 每个结点含一个整型变量. 任何整型变量的范围是 －(215－1)～(215－1)。输入和输出形式: 按中国对于长整数的表示习惯, 每四位一组，组间用逗号隔开。 [ 测试数据 ] (1) 0;0;应输出"0"。 (2) -2345,6789;-7654,3211; 应输出"-1,0000,0000"。 (3) -9999,9999; 1,0000,0000,0000; 应输出"9999,0000,0001"。 (4) 1,0001,0001; -1,0001,0001; 应输出"0"。 (5) 1,0001,0001; -1,0001,0000; 应输出"1"。 [ 实现提示 ] (1) 每个结点可以存放的最大整数为 215-1 = 32767 才能保证两数相加不会溢出。但若这样存，即相当于按 32768 进制数存，在十进制数与 32768 进制数间的转换十分不方便，故可以在每个结点中仅存十进制数的 4 位，即不超过 9999的非负整数, 整个链表被视为万进制。 (2)可以利用头结点数据域的符号代表长整数的符号。 用其绝对值表示元素结点数目。相加过程中不要破坏两个操作数链表。两操作数的头指针存于指针数组中是简化程序结构的一种方法。不能给长整数位数规定上限。 [ 选作内容 ] 修改上述程序，使它在整型量范围是－(2n－1)～(2n－1) 的计算机上都能有效地运行。其中 n 是由程序读入的参量。输入数据的分组方法可另行规定。
长整数加减运算的源代码
03-29
### 长整数加减运算的源代码分析 #### 概述 本文将深入解析一个使用双向循环链表实现的长整数加减运算的程序。该程序能够处理传统整型变量无法表示的大整数，并支持基本的算术运算。 #### 主要组件 程序主要由以下...
双向链表实现长整数运算
ACMiao的博客
12-14 9221
*问题描述：设计一个实现任意长的整数进行加法运算的演示程序。 *基本要求：利用双向循环链表实现长整数的存储，每个结点含一个整形变量。任何整形变量的范围是 -(2^15 - 1)~ (2^15 - 1)。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。  *测试数据： （1）0；0；应输出“0”。 （2）-2345,6789；-7654,3211；应输出“-1,000
长整数四则运算_双向循环链表
wylu
04-07 7830
[ 问题描述 ] 设计程序实现两个任意长整数的求和运算。 [ 基本要求 ] 利用双向循环链表实现长整数的存储, 每个结点含一个整型变量. 任何整型变量的范围是 －(215－1)～(215－1)。输入和输出形式: 按中国对于长整数的表 示习惯, 每四位一组，组间用逗号隔开。 [ 测试数据 ] (1) 0;0;应输出"0"。 (2) -2345,6789;-7654,3211; 应输出"-1,0000...
数据结构课程设计：任意长整数的加减乘运算（c++）
热门推荐
qq_45632864的博客
01-06 1万+
一、课程设计题目 任意长整数的加减乘运算 说明：设计一个程序实现两个任意长整数的加减乘运算。 操作环境：Visual Studio2019或Code::Blocks16.01 二、课程设计主要内容和要求 1．利用双向循环链表，设计一个实现任意长的整数进行加减乘运算的演示程序。 2．要求输入和输出每四位一组，组间用逗号隔开。如：1,0000,0000,0000,0000。 3．计算器的仿真界面。 三、详细设计 3.1 数据结构 实现任意长整数的加减乘运算操作，为方便未知长度的长整数进行运算和存储，所以使用
长整数加减法2021-06-16
weixin_53396137的博客
06-16 137
//输入A，执行长整数加法 //输入B，执行长整数减法 #include<stdio.h> #include<string.h> int main() { void sum(int x[],int y[]); //加法函数 void sub(int x[],int y[]); //减法函数 char c1[80],c2[80]; char c; int i,a1[80]={0},a2[80]={0}; printf("Please put tow num.
长整数减法
m0_62582522的博客
04-02 231
题目描述 计算并输出两个长整数（不小于0，不大于10的100次方）的差，保证结果非负。 输入格式 输入为一组待求差的长整数对，每行为两个长整数。 输出格式 输出每对长整数的差，每个差输出一行。 输入样例 复制 2 1 100000000 50 输出样例 复制 1 99999950 分类标签 高精度计算 #include <iostream> #include<cstring> #include <cstdio> using na.
链表实现长整数加减法
03-22
链表是一种常用的数据结构，可以用来实现长整数的加减法运算。在链表中，每个节点包含一个数字，并且通过指针连接起来形成一个链表。 链表实现长整数加法的步骤如下： 1. 创建两个链表，分别表示两个长整数。 2. 从...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值