【单链表】29 单链表ADT模板应用算法设计:长整数加法运算(使用单链表存储计算结果)

问题描述 :

目的:使用C++模板设计单链表的抽象数据类型(ADT)。并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的应用算法设计。

内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的设计中,推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。)

 

(2)ADT的应用:使用该ADT设计并实现单链表应用场合的算法设计。

 

应用:假设2个任意长度的整数x、y分别由带头结点的单链表A和B存储,现要求设计一个算法,实现任意长的整数进行加法运算,计算结果存储在带头结点的单链表C中。

参考函数原型:

template<class ElemType>

void Long_Int_Add( LinkList<ElemType> &A, LinkList<ElemType> &B, LinkList<ElemType> &C, const int &len_A, const int &len_B );

 

辅助函数原型:

(1)从长整数的低位开始拆分(4位为一组,即不超过9999的非负整数),依次存放在单链表的每个结点的数据域中;头结点的数据域存放正负数标志(正数或0:1,负数:-1)。

template<class ElemType> 

void Input_Int_Division( LinkList<ElemType> &L, string &str, int &length );  (length:长整数分割后的block数,恰为存储用单链表的长度)

(2)计算结果中间位格式控制

string Int_String( int result, int &num );

(3)两个长整数的绝对值大小比较(x>y 返回值为1;x<y 返回值为2;x=y 返回值为0;)

template<class ElemType>

int Two_LongNum_Compare( LinkList<ElemType> &A, LinkList<ElemType> &B, const int &len_A, const int &len_B );

(4)单链表ADT基本操作:单链表的逆置(实际计算时,鉴于单链表的顺序查找的特性,存储在单链表中的长整数需逆置,由原始的高位到低位排列,逆置为低位到高位降序排列。)

template<class ElemType>

void LinkList<ElemType>::ListReverse();

 

输入说明 :

第一行:长整数x

第二行:长整数y

 

输出说明 :

第一行:格式化后的长整数x(从低位到高位每4位用","分开)

第二行:格式化后的长整数y(从低位到高位每4位用","分开)

第三行:空行

第四行:格式化后的计算结果(从低位到高位每4位用","分开)

 

(输入与输出之间用一空行分隔)

输入范例 :

-53456467576846547658679870988098
435643754856985679

输出范例 :

-5345,6467,5768,4654,7658,6798,7098,8098
43,5643,7548,5698,5679

-5345,6467,5768,4611,2014,9250,1400,2419

解题代码: 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <sstream>
#include <stack>
#include <map>
#include <ctime>
#include <array>
#include <set>
#include <list>
using namespace std;
//单链表ADT
/* 单链表的结点定义 */
template<class ElemType>
struct LinkNode
{
	ElemType data;//元素
	LinkNode<ElemType>* next;//next指针
	LinkNode(LinkNode<ElemType>* ptr = NULL)
	{
		//创建节点的时候可以传入next指针
		next = ptr;
	}
	LinkNode(const ElemType& item, LinkNode<ElemType>* ptr = NULL)
	{
		//创建节点的时候可以传入一个元素或者:元素+next指针。
		next = ptr;
		data = item;
	}
};
//带头结点的单链表
template<class ElemType>
class LinkList
{
private:
	LinkNode<ElemType>* head;   // 头指针
	LinkNode<ElemType>* tail;   // 尾指针
	void empty_push(ElemType num)//空链表插入第一个节点
	{
		head = new LinkNode<ElemType>;//头指针指向新建节点
		tail = head;//尾指针指向头指针
		head->data = num;//赋值
		//head->next = NULL;
		return;
	}
	bool check_P(int n)//检查下标是否合法:0-n
	{
		if (0 <= n && n < size())
			return true;
		return false;
	}
public:
	/*

	int size(void)获取长度
	LinkNode<ElemType>* get_address(int i)//获取指定下标的地址
	void have_look(void)   //输出
	void push_back(ElemType num) //尾部插入
	void insert_head(ElemType num) 头部插入
	bool insert_back(int place, ElemType num) 插入到指定位置之后
	*/
	LinkNode<ElemType>* get_head(void)
	{
		LinkNode<ElemType> *&pla = head;
		return pla;
	}
	LinkList()
	{
		//无参数的构造函数
		//head = new LinkNode<ElemType>;//头指针指向新建节点
		//tail = head;//尾指针指向头指针
		head = NULL;
		tail = NULL;
	}
	LinkList(const ElemType& item)
	{
		//带参数的构造函数 我觉得没几个人会用吧
		head = new LinkNode<ElemType>(item);
		tail = head;
	}
	LinkList(LinkList<ElemType>& List)
	{
		//拷贝构造函数
		;
	}
	~LinkList()
	{
		//析构函数

	}
	LinkNode<ElemType>* get_address(int i)//获取指定下标的地址
	{
		LinkNode<ElemType>* pla = head;
		while (i--)
		{
			pla = pla->next;
		}
		return pla;
	}
	void have_look(void)
	{
		LinkNode<ElemType>* p = head;
		while (p->next != NULL)
		{
			cout << p->data;
			cout << "->";
			p = p->next;
		}
		cout << p->data << endl;
		return;
	}
	int size(void)//finish 返回数组的长度
	{
		int len = 0;
		if (head == NULL && tail == NULL)
			return 0;
		LinkNode<ElemType>* p;
		p = head;
		while (p != NULL)
		{
			len++;
			p = p->next;
		}
		return len;
	}
	void push_back(ElemType num)
	{
		if (size() == 0)//空链表特判
		{
			empty_push(num);
			return;
		}
		LinkNode<ElemType>* p = new LinkNode<ElemType>;//新建节点
		p->data = num;//赋值
		tail->next = p;//尾指针指向节点next赋值为p
		tail = p;//尾指针指向p
		return;
	}
	void insert_head(ElemType num)
	{
		if (size() == 0)//空链表特判
		{
			empty_push(num);
			return;
		}
		LinkNode<ElemType>* p = new LinkNode<ElemType>;//新建节点
		p->data = num;//赋值
		p->next = head;//链接
		head = p;
		return;
	}
	bool insert_back(int place, ElemType num)
	{
		if (size() == 0 && place == 0)//空链表特判
		{
			empty_push(num);
			return true;
		}
		if (check_P(place) == false)//位置合法性判断
			return false;
		if (place == size() - 1)//尾部插入特判
		{
			push_back(num);
			return true;
		}
		LinkNode<ElemType>* p = get_address(place);
		LinkNode<ElemType>* p2 = new LinkNode<ElemType>;//新建
		p2->data = num;//赋值
		p2->next = p->next;//定位
		p->next = p2;//链接
		return true;
	}
	LinkNode<ElemType>* get_front(LinkNode<ElemType>* p)//获取一个指针的上一个,头指针和非法指针会报错.
	{
		LinkNode<ElemType>* p1;
		p1 = head;
		while (p1->next != NULL)
		{
			if (p1->next == p)
				return p1;
			p1 = p1->next;
		}
	}
	bool del(int i)//删除指定位置元素  。注意,没有写非法请求检查(0->n-1)
	{
		return del_p(get_address(i));
	}
	bool del_p(LinkNode<ElemType>* p)
	{
		if (size() == 0)
			return false;
		if (head == tail)
		{
			if (p == head)
			{
				delete head;
				head = NULL;
				tail = NULL;
				return true;
			}
			else
				return false;
		}
		if (p == head)
		{
			LinkNode<ElemType>* p1 = head->next;
			delete head;
			head = p1;
			return true;
		}
		if (p == tail)
		{
			LinkNode<ElemType>* p1 = get_front(p);
			delete p;
			p1->next = NULL;
			tail = p1;
			return true;
		}
		LinkNode<ElemType>* p1 = get_front(p);
		p1->next = p->next;
		delete p;
		return true;
	}
	ElemType at(int i)
	{
		LinkNode<ElemType>* p = get_address(i);
		return p->data;
	}
	void reverse(int m, int n)//反转m->n区间
	{
		m++, n++;
		LinkNode<ElemType>* newHead = new LinkNode<ElemType>;
		newHead->next = head;
		LinkNode<ElemType>* p = newHead;
		for (int i = 0; i < m - 1; i++)
			p = p->next;
		LinkNode<ElemType>* start = p->next;
		LinkNode<ElemType>* t = start->next;
		if (n == size())
		{
			tail = start;
		}
		for (int i = m; i < n; i++)
		{
			start->next = t->next;
			t->next = p->next;
			p->next = t;
			t = start->next;
		}
		head = newHead->next;
		return;
	}
	//friend void outnum(LinkList<ElemType>& n, bool a);
};
//LinkList<int> a;
//————————————————
//版权声明:本文为CSDN博主「systemyff」的原创文章,遵循CC 4.0 BY - SA版权协议,转载请附上原文出处链接及本声明。
//原文链接:https ://blog.csdn.net/u014377763/article/details/115442052
void outnum(LinkList<int> &n,bool a)
{
	LinkNode<int>* p;
	p=n.get_head();
	stack<int>lis;
	int t = 0;
	bool allz=0;
	while (p != NULL)
	{
		if (p->data != 0)
			allz = 1;
		p = p->next;
	}
	if (allz==0)
	{
		cout << 0 << endl;
		return;
	}
	p = n.get_head();
	while (p != NULL)
	{
		lis.push(p->data);
		t++;
		p = p->next;
	}
	if (a)
		cout << '-';
	bool fir = 0;
	//cout << t << "t" << endl;
	int ls =4- t % 4;
	while (!lis.empty())
	{
		if (ls % 4 == 0 && fir == 1)
			cout << ",";
		ls++;
		int hc = lis.top();
		lis.pop();
		cout << hc;
		fir = 1;
	}
	cout << endl;
	return;
}
bool huge(LinkList<int>& n1, LinkList<int>& n2)
{
	LinkNode<int>* p1, *p2;
	p1 = n1.get_head();
	p2 = n2.get_head();
	int l1, l2;
	l1 = n1.size();
	l2 = n2.size();
	if (l1 < l2)
		return 1;
	if (l1 > l2)
		return 0;
	stack<int> num1,num2;
	while (p1 != NULL)
	{
		num1.push(p1->data);
		p1 = p1->next;
	}
	while (p2 != NULL)
	{
		num2.push(p2->data);
		p2 = p2->next;
	}
	while (!num1.empty())
	{
		if (num1.top() > num2.top())
			return 0;
		if (num1.top() < num2.top())
			return 1;
		num1.pop();
		num2.pop();
	}
	return 0;
}
int main()
{
	int i, j;
	string s1, s2;
	bool a1, a2;//0==+ 1==-
	cin >> s1 >> s2;
	if (s1[0] == '-')
		a1 = 1;
	else
		a1 = 0;
	if (s2[0] == '-')
		a2 = 1;
	else
		a2 = 0;
	LinkList<int> n1, n2;
	if (a1)
		for (i = s1.size() - 1; i >= 1; i--)
			n1.push_back(s1[i] - '0');
	else
		for (i = s1.size() - 1; i >= 0; i--)
			n1.push_back(s1[i] - '0');
	if (a2)
		for (i = s2.size() - 1; i >= 1; i--)
			n2.push_back(s2[i] - '0');
	else
		for (i = s2.size() - 1; i >= 0; i--)
			n2.push_back(s2[i] - '0');
	outnum(n1, a1);
	outnum(n2, a2);
	cout << endl;
	//大的放前面
	if (huge(n1, n2))
	{
		swap(a1,a2);
		LinkList<int> n3;
		n3 = n1;
		n1 = n2;
		n2 = n3;
		//cout << "A<B" << endl;
	}
	//outnum(n1, a1);
	//outnum(n2, a2);
	//cout << endl;
	LinkList<int> ans;
	if (a1 == a2)//同+同-
	{
		LinkNode<int>* p1, * p2;
		p1 = n1.get_head();
		p2 = n2.get_head();
		int allnum,next_num=0;
		while (p2 != NULL)
		{
			allnum = p1->data + p2->data + next_num;
			
			next_num = allnum / 10;
			allnum = allnum % 10;
			ans.push_back(allnum);
			p1 = p1->next;
			p2 = p2->next;
		}
		while (p1 != NULL)
		{
			allnum = p1->data + next_num;
			next_num = allnum / 10;
			allnum = allnum % 10;
			ans.push_back(allnum);
			p1 = p1->next;
		}
		if (next_num != 0)
			ans.push_back(next_num);
		outnum(ans, a1);
	}
	else//一加一减
	{
		LinkNode<int>* p1, * p2;
		p1 = n1.get_head();
		p2 = n2.get_head();
		int allnum, next_num = 0;
		while (p2 != NULL)
		{
			allnum = p1->data - p2->data + next_num;
			next_num = 0;
			while (allnum < 0)
				allnum += 10, next_num--;
			ans.push_back(allnum);
			p1 = p1->next;
			p2 = p2->next;
		}
		while (p1 != NULL)
		{
			allnum = p1->data + next_num;
			next_num = 0;
			while (allnum < 0)
				allnum += 10, next_num--;
			ans.push_back(allnum);
			p1 = p1->next;
		}
		if (next_num != 0)
			ans.push_back(next_num);
		outnum(ans, a1);
	}
    return 0;
}

 

相关推荐
©️2020 CSDN 皮肤主题: 终极编程指南 设计师:CSDN官方博客 返回首页