2、长整数加法运算

最新推荐文章于 2023-07-08 00:00:00 发布
最新推荐文章于 2023-07-08 00:00:00 发布
阅读量942 收藏 3
点赞数
分类专栏： 数据结构提高25题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014377763/article/details/114435247
版权

出这题目的人就应该拖出去爆莎。

说明：

由于A和B输出时需要从头至尾遍历，而做加法时需要从尾至头遍历，因此使用双向链表存储。

可以从长整数的低位开始拆分（4位为一组，即不超过9999的非负整数），依次存放在链表的每个结点的数据域中；头结点的数据域存放正负数标志（正数或0：1，负数：-1）。

这就是一个简单的高精度加减法运算， 要是说复杂也就仅仅在多位一起计算上增加了一点点。

但是玄妙的地方在于出题人要用双链表？？？

链表的优点在于中间位置插入和删除，虽然说使用链表可以节约最后翻转数字的操作时间，但是却浪费了大量的空间，提高了编程难度。

思路就是同号做加法，异号做减法。

至于双向链表的操作详解，不多说了。

不行了，只有加法用了双向链表，如果减法再用人就无了。

代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
using namespace std;
struct DualNode
{
	int data=0;
	char cc = '+';
	struct DualNode* prior = NULL;
	struct DualNode* next = NULL;
};
int my_pow(int x)
{
	int ans = 1;
	while (x--)
		ans *= 10;
	return ans;
}
void flodput(int n,bool tail)
{
	if (tail)
	{
		if (n == 0)
			return;
		cout << n;
		return;
	}
	if (n < 10)
		cout << "000" << n;
	if (10 <= n && n < 100)
		cout << "00" << n;
	if (100 <= n && n < 1000)
		cout << "0" << n;
	if (1000 <= n)
		cout << n;
}
void out_putj(DualNode* H)
{
	if (H == NULL)
		return;
	DualNode* p, * tail;
	p = H;
	while (1)
	{
		if (p->next == NULL)
		{
			tail = p;
			break;
		}
		p = p->next;
	}
	bool fis = true;
	while (1)
	{
		if (fis)
		{
			flodput(tail->data, true);
			if (tail->prior == NULL)
				cout << endl;
			else
				cout << "->";
			fis = false;
		}
		else
		{
			flodput(tail->data, false);
			if (tail->prior == NULL)
				cout << endl;
			else
				cout << "->";
		}
		if (tail->prior == NULL)
		{
			break;
		}
		tail = tail->prior;
	}
	return;
}
void out_put(DualNode* H)
{
	if (H == NULL)
		return;
	DualNode* p, * tail;
	p = H;
	while (1)
	{
		if (p->next == NULL)
		{
			tail = p;
			break;
		}
		p = p->next;
	}
	bool fis = true;
	while (1)
	{
		if (fis)
		{
			flodput(tail->data, true);
			if (tail->prior == NULL)
				cout << endl;
			else
				cout << ",";
			fis = false;
		}
		else
		{
			flodput(tail->data, false);
			if (tail->prior == NULL)
				cout << endl;
			else
				cout << ",";
		}
		if (tail->prior == NULL)
		{
			break;
		}
		tail = tail->prior;
	}
	return;
}
DualNode* line_add(DualNode* head1, DualNode* head2)
{
	DualNode *ans=NULL,*N=NULL,*Q=NULL;
	DualNode* p1, * p2;
	p1 = head1;
	p2 = head2;
	bool fin = false;
	int carry = 0, l = 0;
	int Tnum;
	while (1)
	{
		Tnum = p2->data + p1->data + carry;//总和计算
		carry = (int)Tnum / 10000;//进位计算
		Tnum = Tnum % 10000;//当前的数字
		//_____________________________
		N = new DualNode;//先新建
		N->data = Tnum;//内容赋值
		l = l + 1;//增加长度
		if (l == 1)
			ans = N;//头节点判断
		else
		{
			Q->next = N;
			N->prior = Q;
		}
		Q = N;
		//----------
		//如果A、B的长度相同
		if (p1->next == NULL && p2->next == NULL)
		{
			if (carry != 0)
			{
				//----------
				N = new DualNode;//先新建
				N->data = carry;//内容赋值
				l = l + 1;//增加长度
				if (l == 1)
					ans = N;//头节点判断
				else
				{
					Q->next = N;
					N->prior = Q;
				}
				Q = N;
				//----------
			}
			return ans;
		}
		//如果B比A短
		if (p2->next == NULL)
		{
			p1 = p1->next;
			break;
		}
		p1 = p1->next;
		p2 = p2->next;
	}
	while (1)
	{
		Tnum = p1->data + carry;//总和计算
		carry = (int)Tnum / 10000;//进位计算
		Tnum = Tnum % 10000;//当前的数字
		//----------------------
		N = new DualNode;//先新建
		N->data = Tnum;//内容赋值
		l = l + 1;//增加长度
		if (l == 1)
			ans = N;//头节点判断
		else
		{
			Q->next = N;
			N->prior = Q;
		}
		Q = N;
		//---------------------
		if (p1->next == NULL)
		{
			if (carry != 0)
			{
				//----------
				N = new DualNode;//先新建
				N->data = carry;//内容赋值
				l = l + 1;//增加长度
				if (l == 1)
					ans = N;//头节点判断
				else
				{
					Q->next = N;
					N->prior = Q;
				}
				Q = N;
				//----------
			}
			break;
		}
		p1 = p1->next;
	}
	return ans;
}
int my_compare(string s1, string s2)
{
	if (s1.length() > s2.length()) 
		return 1;
	else if (s1.length() < s2.length())  
		return -1;
	else 
		return s1.compare(s2);
}
DualNode* line_sub(DualNode* head1, DualNode* head2)
{
	DualNode* ans = NULL, * N = NULL, * Q = NULL;
	DualNode* p1, * p2;
	p1 = head1;
	p2 = head2;
	bool fin = false;
	int carry = 0, l = 0;
	int Tnum;
	while (1)
	{
		if (p1->data > p2->data)
			;
		Tnum = p1->data - p2->data + carry;//总和计算
		carry = (int)Tnum / 10000;//进位计算
		Tnum = Tnum % 10000;//当前的数字
		//_____________________________
		N = new DualNode;//先新建
		N->data = Tnum;//内容赋值
		l = l + 1;//增加长度
		if (l == 1)
			ans = N;//头节点判断
		else
		{
			Q->next = N;
			N->prior = Q;
		}
		Q = N;
		//----------
		//如果A、B的长度相同
		if (p1->next == NULL && p2->next == NULL)
		{
			if (carry != 0)
			{
				//----------
				N = new DualNode;//先新建
				N->data = carry;//内容赋值
				l = l + 1;//增加长度
				if (l == 1)
					ans = N;//头节点判断
				else
				{
					Q->next = N;
					N->prior = Q;
				}
				Q = N;
				//----------
			}
			return ans;
		}
		//如果B比A短
		if (p2->next == NULL)
		{
			p1 = p1->next;
			fin = false;
			break;
		}
		//如果A比B短
		if (p1->next == NULL)
		{
			p2 = p2->next;
			fin = true;
			break;
		}
		p1 = p1->next;
		p2 = p2->next;
	}
	while (1)
	{
		Tnum = p1->data + carry;//总和计算
		carry = (int)Tnum / 10000;//进位计算
		Tnum = Tnum % 10000;//当前的数字
		//----------------------
		N = new DualNode;//先新建
		N->data = Tnum;//内容赋值
		l = l + 1;//增加长度
		if (l == 1)
			ans = N;//头节点判断
		else
		{
			Q->next = N;
			N->prior = Q;
		}
		Q = N;
		//---------------------
		if (p1->next == NULL)
		{
			if (carry != 0)
			{
				//----------
				N = new DualNode;//先新建
				N->data = carry;//内容赋值
				l = l + 1;//增加长度
				if (l == 1)
					ans = N;//头节点判断
				else
				{
					Q->next = N;
					N->prior = Q;
				}
				Q = N;
				//----------
			}
			break;
		}
		p1 = p1->next;
	}
	return ans;
}
string sub(string str1, string str2)
{
	string str;
	int tmp = str1.length() - str2.length();
	int cf = 0;
	for (int i = str2.length() - 1; i >= 0; i--)
	{
		if (str1[tmp + i] < str2[i] + cf)
		{
			str = char(str1[tmp + i] - str2[i] - cf + '0' + 10) + str;
			cf = 1;
		}
		else
		{
			str = char(str1[tmp + i] - str2[i] - cf + '0') + str;
			cf = 0;
		}
	}
	for (int i = tmp - 1; i >= 0; i--)
	{
		if (str1[i] - cf >= '0')
		{
			str = char(str1[i] - cf) + str;
			cf = 0;
		}
		else
		{
			str = char(str1[i] - cf + 10) + str;
			cf = 1;
		}
	}
	str.erase(0, str.find_first_not_of('0'));
	return str;
}
void inPart(string a, string b, char c1, char c2)
{
	int i, j;
	int len1 = 0, len2 = 0;
	DualNode* head1=NULL, * head2=NULL, * N=NULL, * Q=NULL;
	int t, number;
	//----------------------
	head1 = NULL;
	t = 0, number = 0;
	for (i = a.length() - 1; i >= 0; i--)
	{
		number += (a[i] - '0') * my_pow(t);
		t++;
		if (t % 4 == 0 || (a.length() % 4 != 0 && i == 0))
		{
			//cout << "NU=" << number << endl;
			t = 0;
			//----------
			N = new DualNode;//先新建
			N->data = number;//内容赋值
			len1 = len1 + 1;//增加长度
			if (len1 == 1)
				head1 = N;//头节点判断
			else
			{
				Q->next = N;
				N->prior = Q;
				//head1->prior = N;
			}
			Q = N;
			number = 0;
		}

	}
	if (c1 == '-')
		cout << '-';
	out_put(head1);
	//----------------------
	head2 = NULL;
	t = 0, number = 0;
	for (i = b.length() - 1; i >= 0; i--)
	{
		number += (b[i] - '0') * my_pow(t);
		t++;
		if (t % 4 == 0 || (b.length() % 4 != 0 && i == 0))
		{
			//cout << "NU=" << number << endl;
			t = 0;
			//----------
			N = new DualNode;//先新建
			N->data = number;//内容赋值
			len2 = len2 + 1;//增加长度
			if (len2 == 1)
				head2 = N;//头节点判断
			else
			{
				Q->next = N;
				N->prior = Q;
				//head2->prior = N;
			}
			Q = N;
			number = 0;
		}

	}
	if (c2 == '-')
		cout << '-';
	out_put(head2);
	cout << endl;
	DualNode* ans;
	if (c1 == c2)
	{
		//cout << "len1" << len1<<endl;
		//cout << "len2" << len2<<endl;
		if (len2 > len1)
			swap(head1, head2);
		ans = line_add(head1, head2);
		out_putj(ans);
		if (c1 == '-')
			cout << '-';
		out_put(ans);
	}
	else
	{
		if(my_compare(a,b)==-1)
		{
			swap(a, b);
			swap(c1, c2);
		}
		if (my_compare(a, b) == 0)
		{
			cout << 0 << endl;
			cout << 0 << endl;
			return;
		}
		string an = sub(a, b);
		int lend = an.length();
		int strl = lend % 4;
		if (strl != 0)
		{
			for (i = 0; i < strl; i++)
			{
				cout << an[i];
			}
			if (i != lend)
				cout << "->";
			else
				cout << endl;
		}
		int hdt = 0;
		for (i = strl; i <lend; i++)
		{
			hdt++;
			cout << an[i];
			if (hdt % 4 == 0)
			{
				hdt = 0;
				if (i != lend - 1)
					cout << "->";
				else
					cout << endl;
			}
		}
		if (c1 == '-')
			cout << '-';
		if (strl != 0)
		{
			for (i = 0; i < strl; i++)
			{
				cout << an[i];
			}
			if (i != lend)
				cout << ',';
			else
				cout << endl;
		}
		hdt = 0;
		for (i = strl; i < lend; i++)
		{
			hdt++;
			cout << an[i];
			if (hdt % 4 == 0)
			{
				hdt = 0;
				if (i != lend - 1)
					cout << ",";
				else
					cout << endl;
			}
		}
	}
	return;
}
int main()
{
	int n;
	string s1, s2;//输入
	char c1 = '+', c2 = '+';//储存正负号
	cin >> s1 >> s2;
	if (s1[0] == '-')
	{
		c1 = '-';
		s1.erase(0, 1);
		//return 0;
	}
	if (s2[0] == '-')
	{
		c2 = '-';
		s2.erase(0, 1);
		//return 0;
	}
	//cout << s1 << endl;
	//cout << s2 << endl;
	inPart(s1, s2, c1, c2);
	return 0;
}

 

 

 

 

systemyff
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
长整数_长整数；基本运算_
09-29
1. **加法(+)**：两个长整数相加，可以通过将它们的二进制表示拼接起来然后进行加法运算得到结果。在C++中，你可以直接使用`+`操作符来实现这个操作，编译器会自动处理溢出的问题。 2. **减法(-)**：减法与加法类似...
长整数加法运算（双向链表）
qq_40637545的博客
06-20 2480
长整数加法运算问题描述输入说明输出说明 问题描述 假设2个任意长度的整数x、y分别由双向链表A和B存储，现要求设计一个算法，实现x+y。计算结果存储在链表C中。 说明： 由于A和B输出时需要从头至尾遍历，而做加法时需要从尾至头遍历，因此使用双向链表存储。 可以从长整数的低位开始拆分（4位为一组，即不超过9999的非负整数），依次存放在链表的每个结点的数据域中；头结点的数据域存放正负数标志（正数或0：1，负数：-1）。 输入说明 第一行：长整数x 第二行：长整数y 输出说明 第一行：格式化后的长整数x（从低位
链表问题——长整数加法运算题解【双向链表】
最新发布
cold的博客
07-08 1359
假设2个任意长度的整数x、y分别用链表A和B存储，现要求设计一个算法，实现x+y。计算结果存储在链表C中。链表A、B、C可以是单向链表或双向链表，但由于A和B输出时需要从头至尾遍历，而做加法时需要从尾至头遍历，因此推荐使用双向链表存储。链表的每个结点的数据域可以选择以下三种设计方式：（1）链表的每个结点存储长整数的一位（不推荐）；（2）链表的每个结点从长整数的低位开始拆分（4位为一组，存到一个结点中，即结点的数据域为不超过9999的非负整数），依次存放在链表的每个结点；
任意长的整数加减法运算
weixin_42000656的博客
09-23 8616
题目要求：设计算法，实现一个任意长的整数进行加法、减法运算的演示程序。例如：1234，5123，4512，3451，2345与-1111，1111，1111，1111，1111的加法结果为：0123，4012，3401，2340，1234。基本要求如下： （1） 利用链表实现长整数的存储，每个节点含一个整型变量； （2） 整型变量的范围：-（2^15 -1）~（2^15 -1）； （3） 输入与输...
长整数加法
qq_43460108的博客
03-07 355
2.15 长整数加法 问题描述 　　输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。 算法描述 　　由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。 　　定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。 　　计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。
C++基础与深度解析 || 长整数加法
qq_36291615的博客
09-06 965
一个文件中包含两行数字序列，每行数字序列表示一个十进制长整数（只包含0~9与符号位，如果存在符号位，那么只能处于开头位置)。你的程序应当接收一个输入参数，表示该文件，程序读取这两个序列并求二者之和，将结果输入到屏幕上。需要注意的是，由于序列可能比较长，因此其对应的数值可能无法使用一个内建数据类型来保存。需要使用一个数组（或vector)来保存每一位的数值。
C++堆栈实现超长整数加法
06-07
在超长整数加法中，我们可以将每个数字位看作一个元素，逐位进行操作，通过堆栈来存储这些位。 首先，我们需要定义一个堆栈类来存放超长整数的每一位。这个类通常包含两个主要部分：一个数组用于存储数据，以及一个...
长整数加减运算
01-03
实现长整数加法的过程如下： 1. 初始化两个链表，分别代表两个长整数。它们的节点按逆序排列，存储各自的数字位。 2. 创建一个新的空链表用于存储结果。 3. 按顺序比较两个链表的当前节点，如果两个节点都非零，则...
任意长的整数进行加法运算
01-15
利用双向循环链表实现长整数的存储，每个结点含一个整形变量。任何整形变量的范围是 -(2^15 - 1)~ (2^15 - 1)。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。 这是我用java写的，使用...
任意长整数加法
04-28
"任意长整数加法"指的是可以处理超过Java内置数据类型（如int和long）表示范围的整数相加操作。这是因为Java中的int类型能存储的最大值是2^31 - 1，long类型能存储的最大值是2^63 - 1，对于更大数值的计算，我们需要...
长整数四则运算加减法
07-18
1、本程序实现计算任意长的整数的加、减法运算. 以用户和计算机对话的方式，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令，然后程序就计算并显示出这两个数的运算。 2、本演示程序中，集合的元素限定为数字字符[‘0’~’9’]和字符‘，’与‘；’，输入字符可以任意长，输入形式以“回车符”为结束标志，串中字符顺序不限，且允许出现重复字符。3、利用双向循环链表现实长整数的存储，每个结点含一个整形变量。输入的形式以回车结束，可以直接输入正数或负数。按中国对于长整数的表示习惯，每四位一组，除数字和位于首位置的负号外，其它一切字符都将作为分隔符，连续多个分隔符当一个处理。但不使用分隔符也不影响结果。
长整数加减
12-09
长整数加减，两数相加大于9向前一位进一，当最高位大于9则不进一，两数相加大于9向前一位进一，当最高位大于9则不进一
C语言中长短整型数据之间的相互转换及运算-其实很简单
C20130911
12-07 8115
长转短直接截取长整的低字节原封不动放到短整上短转长1. 无符号的短整， 转为长整（长整是否有符号，不关心） 短整原封不动地放置到长整的低字节上 2. 有符号的短整， 转为长整（长整是否有符号，不关心） 与前一种无符号的情况相比，多了一步：扩展符号位（短整的最高位），长整的高字节全部置成短整的符号位的值。相互运算 短整一律转成整型（int） 整型之间的算术运算（包括比较），
长整数的加减运算（数组）
sadnessss的博客
10-20 1388
长整数的每位上的数字必须为数字[0——9]之间。测试的时候输入数据，当输入回车键的时候结束输入，如果输入的字符不符合题目要求，则程序能过滤这些不符合要求的字符。 #include <stdio.h> #include <stdlib.h> #include <string.h> #define M 10000 void add(char*b1,char*b2) //加法 { int i=0,j=0; int len1=strlen(b1); //
长整数加法运算
m0_50690578的博客
04-18 521
27 单链表ADT模板应用算法设计：长整数加法运算（不使用单链表存储计算结果） 作者: 冯向阳时间限制: 1S章节: DS:线性表 晚于: 2021-04-18 23:55:00后提交分数乘系数50% 截止日期: 2021-04-18 23:55:00 问题描述 : 目的：使用C++模板设计单链表的抽象数据类型（ADT）。并在此基础上，使用单链表ADT的基本操作，设计并实现单链表的应用算法设计。
长整数加减法运算
CHN_Zgq's Blog
11-27 2729
长整数加减法运算 【问题描述】 设计一个实现任意长的整数进行加法和减法运算的演示程序。 【基本要求】 利用双向循环链表实现长整数的存储，每个结点含一个整型变量。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。 【测试数据】 (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
有链表实现长整数的加法
小蝌蚪的Blog
04-15 5108
课程题目：          设计一个程序实现两个任意长的整数求和运算。要求：          利用双向循环链表实现长整数的存储，每个节点含有一个整型变量。 输入形式按照中国对于长整数的表示习惯，没四位一组，组间用逗号隔开。思路：         为了达到上面的要求，我使用链表将长整数按照四位一组进行输入（每组用一个int表示就可以了）。然后对链表中的数字进行加法运算。   
[数据结构]长整数加法运算(链表）
codeTcy的博客
07-07 6397
长整数加法运算(链表） 问题描述 : 假设2个任意长度的整数x、y分别由双向链表A和B存储，现要求设计一个算法，实现x+y。计算结果存储在链表C中。 说明： 由于A和B输出时需要从头至尾遍历，而做加法时需要从尾至头遍历，因此使用双向链表存储。 可以从长整数的低位开始拆分（4位为一组，即不超过9999的非负整数），依次存放在链表的每个结点的数据域中；头结点的数据域存放正负数标志（正数或0：1，负数：-1）。 输入说明 : 第一行：长整数x 第二行：长整数y 输出说明 : 第一行：格式化后的长整数x（从低位到高
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值