mywork.cpp

设计一个一元稀疏矩阵多项式简单计算器。用带表头节点的单链表存储多项式

#include"Myworkh.h"
template<class T>
Multi<T>::Multi(T a[],int b[],int m)//构造函数，将系数a数组，和次数b数组考入
{   
	
	node<T> *s;//定义指针
	first=new node<T>;//新建一个头结点
	r=first;//指针r指向头结点
	first->data2=m;//将m的值的赋给头结点
	for(int i=0;i<m;i++)//进行从0到m循环
	{
		s=new node<T>;//给s申请动态空间
		s->data1=a[i];//将数组a的值赋给头结点
		s->data2=b[i];//将数组b的值赋给头结点
		r->next=s;//把s赋给r 指向的下一个指针
		r=s;//把s赋给r
	}
	r->next=NULL;//循环结束,尾指针置空
}
template<class T>
Multi<T>::Multi(Multi<T> &a)//重载构造函数，用于参数传递
{   
	node<T> *s;//定义指针
	first=new node<T>;//新建一个头结点
	first->data2=0;//头结点的数据初始
	r=first;//指针r指向头结点
	a.p=a.first->next;//指针p初始,a.first->next表示系数的头指针的下一个指针
	while(a.p)//循环至指针为空
	{
		s=new node<T>;
		s->data1=a.p->data1;//进行参数传递
		s->data2=a.p->data2;
		r->next=s;
		r=s;//r后移
		a.p=a.p->next;//p后移
		first->data2++;//纪录多项式的个数
		
	}
	r->next=NULL;//循环结束,尾指针置空
	
	
}
template<class T>
void Multi<T>::paixu()//将数组进行升幂排序
{
	T m;
	int n;
	int l=1;//变量,累加器初始
	
	while(l)//冒泡排序，直到不再交换为止
	{  l=0;
	p=first->next;//指针,累加器初始
	while(p->next)//循环直到指针为空
	{
		if(p->data2>p->next->data2)//判断前一个指针数据大于下一个，如果是那么需要交换两个数据
		{
			m=p->data1;//复制之前保证两个数据属于同一个类型
			n=p->data2;//将指针的数据赋给变量
			p->data1=p->next->data1;//将下一个指针数据1赋给当前的
			p->data2=p->next->data2;//将下一个指针数据2赋给当前的
			p->next->data1=m;//将变量值赋给指针
			p->next->data2=n;
			l++;//累加器加1
		}
		p=p->next;//进行下一个指针
	}//借助M。N来完成当前指针和下一个指针数据的交换
	
	
	}
	
	//将同指数的的项合并
	p=first;//指针初始
	while(p->next)//循环至指针为空
	{
		if(p->data2==p->next->data2)//判断前一个指针数据等于下一个
		{   node<T> *g;//定义指针g，用于删除结点
		p->data1+=p->next->data1;//指数相等,相加
		g=p->next;
		p->next=g->next;//指针传递
		delete g;//释放传递指针
		first->data2--;//项数减一
		}
		else if(p->next)//满足不相等进行下一个指针
			
		{
			p=p->next;
		}
		else
			continue;
	}
}
template<class T>
Multi<T>::~Multi()//析构函数
{  
	node<T> *g;
	p=first;//指针初始
	int j=p->data2;
	for(int i=0;i<=j;i++)
	{
		g=p;
		p=p->next;//指针传递
		delete g;//释放指针
	}
}
template<class T>
void Multi<T>::chongzhi(T a[],int b[],int m)
{
	node<T> *g;
	p=first;
	int j=p->data2;//指针初始
	for(int i=0;i<=j;i++)//循环至最高指数
	{
		g=p;
		p=p->next;//需将G站用的地址内存空间释放以免造成内存浪费
		delete g;//全部释放原来的多项式
	}
	
	node<T> *s;
	first=new node<T>;
	r=first;
	first->data2=m;//指数赋值
	for(int p=0;p<m;p++)//循环至最高指数
	{
		s=new node<T>;
		s->data1=a[p];
		s->data2=b[p];//多项式一一赋值
		r->next=s;
		r=s;
	}
	r->next=NULL;//尾指针滞空
	
}
template<class T>
void  Multi<T>::printlist()
{
	p=first;//第一个节点的判断
	p=p->next;
	int j=0;//指针,累加器初始    j>=first->data2)，判断多项式是否为0
	if(p)//p指针不为空
			 { if(p->data2)//指数不为0
			 
	{    
			     if(p->data1>0)//输出第一个数据
					 
				 {
					 cout<<p->data1<<'x'<<p->data2;
					 
				 }
				 else if(p->data1<0)
				 {
					 cout<<p->data1<<'x'<<p->data2;
					 
				 }
				 else if(p->data1==0)
				 { 
					 j++;
				 }
				 
	}
	
				
	else//指数为0时
		cout<<p->data1;
			 }
	
	while(p)//循环至指针不为空
			 {   
		p=p->next;//指向下一个
		
		if(p)//判断指针不为空
		{ 
			if(p->data2!=0)//判断指数不为空
				
			{   
				if(p->data1>0)//判断系数正负
					
				{
					cout<<" + "<<p->data1<<'x'<<p->data2;
					
				}
				else if(p->data1<0)
				{
					cout<<p->data1<<'x'<<p->data2;
					
				}
				else if(p->data1==0)
				{ 
					j++;//累加器加一
				}
			}
			else//指数为0直输出系数
				
			{
				cout<<' + '<<p->data1;
				
			}
		}
	}
	if(j>=first->data2)//判断多项式是否为0
	{
		cout<<'0';
	}
	cout<<endl;
}
template<class T>
Multi<T> operator +(Multi<T> &c1,Multi<T> &c2)//重载运算符+
{             
	
	c1.r->next=c2.first->next;//将c2连入c1之后
	
	
	Multi<T> c3(c1);//定义c3赋c1的值
	c3.paixu();//调用paixu
	c3.printlist();//  输出
	c1.r->next=NULL;
	return c3;
	
	
}
template<class T>
Multi<T> operator -(Multi<T> &c1,Multi<T> &c2)//重载运算符-
{   
	
	c2.p=c2.first->next;//c2的p指针初始	
	
	while(c2.p)//将c2变为负，循环知道c2为空
	{
		c2.p->data1=-c2.p->data1;
		c2.p=c2.p->next;
	}
	Multi<T> c3(c1+c2);//定义c3赋c1与-c2
	   return c3;
}


template<class T>
double Multi<T>::fuzhi(double z)//赋值运算
{   
	double s=0;//变量初始，及如果没有进行复制旧默认为0
	p=first->next;//指针初始
	while(p)//指针p为空才结束
	{
		s=s+p->data1*pow(z,p->data2);//赋值运算 pow 算z 的幂
		p=p->next;
	}
	return s;
}