package Linear;
/*
 * 一元多项式相加：ha指向表头结点，hb指向表头结点，将俩多项式相加，并加入p表。
 * 
 * 补充知识点：
 * 释放p结点操作 1、Node t=p; t=null;
 */

public class C {
	public static void Add(multipleNode ha,multipleNode hb) {
		multipleNode p =ha.next;
		multipleNode pre=ha;	//pre永远指向p的前一结点
		multipleNode q=hb.next;
		while(p!=null&&q!=null) {
			if (p.exp<q.exp) {	//p指数小于q指数
				pre=p;
				p=p.next;
			}else if(p.exp==q.exp) {	//p指数等于q指数
				int x=p.coef+q.coef;
				if(x==0) {				//系数相加为0，删除结点
					pre.next=p.next;
					p=null;
					p=pre.next;
				}else {					//相加不为0，将q点加入p表（即删除q结点，p修改系数）
					p.coef=x;
					multipleNode t =q;
					q=q.next;
					t=null;
				}
			}else {						//p指数大于q指数，将q加入p表（即将q结点插入在p结点之前）
				multipleNode t =q.next;
				q.next=p;
				pre.next=q;
				pre=q;
				q=t;
			}
		}
		if (q!=null) {
			p.next=q;
		}
		hb.next=null;
		hb=null;
	}
	public static void main(String[] args) {
		int[][] arrA=new int[][]{{1,2},{2,3}};
		int[][] arrB=new int[][]{{1,1},{2,2}};
		multipleNode A=NodeTool.CreateNodeList(arrA);
		multipleNode B=NodeTool.CreateNodeList(arrB);
		NodeTool.traverseWithHead(A);
		NodeTool.traverseWithHead(B);
		Add(A, B);
		NodeTool.traverseWithHead(A);
		NodeTool.traverseWithHead(B);
	}

}


 

实验名称：一元多项式相加
1 //multiply.cpp : 定义控制台应用程序的入口点。2 //3
4 #include "stdafx.h"
5 #include
6 #include "stdio.h"
7 using namespacestd;8
9
10 /***********************定义多形式的数据结构*************************/
11 typedef structNode12 {13   int coef;      //多项式系数
14   int exp;         //多项式指数
15   struct Node *next;//指向下一项的指针
16 } Node,*LinkList;   //定义了一个Node型指针的别名LinkList;
17
18 /***********************多项式初始化*************************/
19 void initpoly (LinkList &px)20 {21    px = newNode;22    px ->next =NULL;23 }24
25 /***********************多项式创建*************************/
26 void creatpoly (LinkList &px,intn )27 {28     LinkList p=NULL,q=NULL;  //q是用来开辟空间的。
29     p = px;      //p是用来存储整个链表的。    这里px相当于一个全局的指针变量一样。
30     for(int i = 0; i < n; i++)31 {32         q = newNode;33         cout << "请输入第" << i << "项的系数："<> q ->coef;35         cout << "请输入第" << i << "项的指数："<> q ->exp;37         q ->next =NULL;38         p ->next = q;//链表向前一直在扩大。
39         p =q;40 }41 }42
43
44 int lengthpoly(LinkList &px) //计算多项式的项数。
45 {46     LinkList p =NULL;47     int count = 0;48     p = px ->next;49     while(p !=NULL)50 {51         p = p ->next;52         count++;53 }54     returncount;55 }56 /***********************多项式输出*************************/
57 void outputpoly(LinkList &px)58 {59     LinkList p =NULL;60     p = px ->next;61     for(int i = 0;i < lengthpoly(px);i++)62 {63         cout << p ->coef << "*X^" << p->exp << "+";64         p = p ->next;65 }66     cout << "0" <
69 //void addpoly(LinkList &pa,LinkList &pb,LinkList &pc)70 //{71 //LinkList la=NULL,lb=NULL,lc=NULL,r=NULL;72 //la = pa ->next;73 //lb = pb ->next;74 //lc = pc;//prep是用来存储整个a+b的链表的。75 //while(la&&lb)//a与b其中一个不为076 //{77 //if(la ->exp < lb ->exp)//a的指数小78 //{79 //r = new Node;80 //r ->coef = la ->coef;81 //r ->exp = la ->exp;82 //lc ->next = r;83 //lc = r;84 //r ->next = NULL;85 //la = la ->next;86 //}87 //else if(la ->exp > lb ->exp)88 //{89 //r = new Node;90 //r ->coef = lb ->coef;91 //r ->exp = lb ->exp;92 //lc ->next = r;93 //r ->next = NULL;94 //lc = r;95 //lb = lb ->next;96 //}97 //else98 //{99 //int sum = la ->coef + lb ->coef;100 //if(sum != 0)101 //{102 //r = new Node;103 //r ->coef = sum;104 //r ->exp = la ->exp;105 //lc ->next = r;106 //r ->next = NULL;107 //lc = r;108 //la = la ->next;109 //lb = lb ->next;110 //}111 //else112 //{113 //la = la ->next;114 //lb = lb ->next;115 //}116 //}117 //
118 //}119 //while(la != NULL)120 //{121 //r = new Node;122 //r ->coef = la ->coef;123 //r ->exp = la ->exp;124 //lc ->next = r;125 //lc = r;126 //r ->next = NULL;127 //la = la ->next;128 //}129 //while(lb != NULL)130 //{131 //r = new Node;132 //r ->coef = lb ->coef;133 //r ->exp = lb ->exp;134 //lc ->next = r;135 //lc = r;136 //r ->next = NULL;137 //lb = lb ->next;138 //}139 //}
140
141 Node * addDuoX(LinkList &Pa,LinkList &Pb)//关键部分，A与B相加
142 {143     Node *p,*q;144     Node *prep;145     Node *u;146
147     p = Pa->next;148     q = Pb->next;149
150     prep=Pa;151
152     while (p&&q)//Ａ与Ｂ都不等于０
153 {154         if(p->expexp)//A的指数小于B的指数
155 {156             prep=p;157             p=p->next;158 }159         else if(p->exp > q->exp)//A的指数大的话
160 {161             u=q->next;162
163             q->next=p;164             prep->next=q;165
166             prep=q;167             q=u;168 }169         else//A与B的指数相等的话
170 {171             p->coef=p->coef+q->coef;172             if(p->coef==0)//A与B的指数相等的话,且其中A的系数为0
173 {174                 Node *temp1;175                 Node *temp2;176                 temp1=p;177                 temp2=q;178                 prep->next=p->next;//删除该项数
179                 p=p->next;180                 q=q->next;181
182 delete temp1;183 delete temp2;184 }185             else//A与B的指数相等的话,且其中A的系数为0，B的系数为0
186 {187                 Node *temp2;188                 temp2=q;189
190                 prep=p;191                 p=p->next;192                 q=q->next;193 delete temp2;194 }195 }196 }197     if(q)198         prep->next=q;199
200 delete Pb;201     returnPa;202 }203
204
205 //再做一个小的处理，先合并同类型。对指数相同的进行相加，并删去其中一个，合并同类项
206 void hebing(Node *px)207 {208     Node *p = NULL,*q =NULL;209     p = px ->next;210     q = newNode;211     while(p->next!=NULL)212 {213         q = p ->next;214         if(p ->exp == q ->exp)215 {216             p ->coef = p->coef + q->coef;217             p -> next = q ->next;218              //p 不在受q约束,一直不受其约束。
219 delete(q);220 }221         p = p ->next;222 }223 }224 /*** 程序中用了选择排序 ***/
225 void paixu(Node *px)226 {227     //用选择排序怎么做
228     Node *p = NULL,*q =NULL;229     p = px ->next; //此时开辟了内存空间。
230     q = px ->next;231     int temp; //注：类初始化化时需要加上()，而结构体初始化不需要。
232     for(p ;p!= NULL;p = p ->next)  //这玩意就相当于i++,
233 {234         for(q = p ->next; q!= NULL; q = q ->next ) //为什么不用q -> next，因为q = p -> next 了。
235 {236             if(p ->exp > q ->exp)   //我真是弄错啦，我现在只需要把结点里面的值换掉就行了，何必换掉整个的结点，这样位置肯定出问题。
237 {238                 temp = p ->exp;239                 p ->exp = q ->exp;240                 q ->exp =temp;241
242                 temp = p ->coef;243                 p ->coef= q ->coef;244                 q ->coef =temp;245 }246 }247 }248 }249
250
251 intmain()252 {253     LinkList pa = NULL,pb = NULL,pc =NULL;254 initpoly(pa);255 initpoly(pb);256 initpoly(pc);257     inta,b;258
259     cout << "输入第一个多项式的项数："<>a;261     cout << "输入第二个多项式的项数："<>b;263     cout << "请按升序输入："<
275     pc =addDuoX(pa,pb);276 outputpoly(pc);277     cin >>b;278 delete(pa);279 delete(pb);280 delete(pc);281     return 0;282 }
实验目的：练习并掌握如何使用C++语言实现链表的说明、创建等操作。
实验要求：能实现一元多项式的输入、输出，以及两个一元多项式相加及结果显示。(具体内容请参照数据结构实验内容)
实验步骤及内容：
1、首先建立一个定义多项式的结构体Node，及结构体指针LinkList，该结构体包含一个指数exp，一个系数coef，一个指向下一项的指针*next,代码如下：
typedef struct Node
{
int coef;      //多项式系数
int exp;         //多项式指数
struct Node *next;//指向下一项的指针
} Node,*LinkList;   //定义了一个Node型指针的别名LinkList;
2、初始化多项式，代码如下：
void initpoly (LinkList &px)
{
px = new Node;
px ->next = NULL;
}
3、建立多项式，用来指导用户输入程序运行时所需要的必须得数据，两个一元多项式的项数、系数、指数。具体的代码如下：
void creatpoly (LinkList &px,int n )
{
LinkList p=NULL,q=NULL;  //q是用来开辟空间的。
p = px;      //p是用来存储整个链表的。
for(int i = 0; i < n; i++)
{
q = new Node;
cout << "请输入第" << i << "项的系数："<< endl;
cin >> q ->coef;
cout << "请输入第" << i << "项的指数："<< endl;
cin >> q ->exp;
q ->next = NULL;
p ->next = q;
p = q;
}
}
4、求一个多形式的长度，主要用来获取一个多形式的长度，便于输出。
int lengthpoly(LinkList &px) //计算多项式的项数
{
LinkList p = NULL;
int count = 0;
p = px ->next;
while(p != NULL)
{
p = p ->next;
count++;
}
return count;
}
5、输出多形式，此函数用来对多项式进行输出验证。
void outputpoly(LinkList &px)
{
LinkList p = NULL;
p = px ->next;
for(int i = 0;i < lengthpoly(px);i++)
{
cout << p ->coef << "^" << p->exp << "+";
p = p ->next;
}
cout << "0" << endl;
}
6、多项式相加，输出也是按序排列。当两个多项式都不为0时，进行相加，然后剩下的部分直接赋给相加后的多项式，前提是输入的多形式必须是按顺序排列的。代码如下：
void outputpoly(LinkList &px)
{
LinkList p = NULL;
p = px ->next;
for(int i = 0;i < lengthpoly(px);i++)
{
cout << p ->coef << "*X^" << p->exp << "+";
p = p ->next;
}
cout << "0" << endl;
}
void addpoly(LinkList &pa,LinkList &pb,LinkList &pc)
{
LinkList la=NULL,lb=NULL,lc=NULL,r=NULL;
la = pa ->next;
lb = pb ->next;
lc = pc;     //prep是用来存储整个a+b的链表的。
while(la&&lb)//a与b其中一个不为
{
if(la ->exp < lb ->exp)  //a的指数小
{
r = new Node;
r ->coef = la ->coef;
r ->exp = la ->exp;
lc ->next = r;
lc = r;
r ->next = NULL;
la = la ->next;
}
else if(la ->exp > lb ->exp)
{
r = new Node;
r ->coef = lb ->coef;
r ->exp = lb ->exp;
lc ->next = r;
r ->next = NULL;
lc = r;
lb = lb ->next;
}
else
{
int sum = la ->coef + lb ->coef;
if(sum != 0)
{
r = new Node;
r ->coef = sum;
r ->exp = la ->exp;
lc ->next = r;
r ->next = NULL;
lc = r;
la = la ->next;
lb = lb ->next;
}
else
{
la = la ->next;
lb = lb ->next;
}
}
}
while(la != NULL)
{
r = new Node;
r ->coef = la ->coef;
r ->exp = la ->exp;
lc ->next = r;
lc = r;
r ->next = NULL;
la = la ->next;
}
while(lb != NULL)
{
r = new Node;
r ->coef = lb ->coef;
r ->exp = lb ->exp;
lc ->next = r;
lc = r;
r ->next = NULL;
lb = lb ->next;
}
}
7、主函数代码如下，为了便于交互，所以增加了好些用户提示符：
int main()
{
LinkList pa = NULL,pb = NULL,pc = NULL;
initpoly(pa);
initpoly(pb);
initpoly(pc);
int a,b;
cout << "输入第一个多项式的项数："<
cin >> a;
cout << "输入第二个多项式的项数："<
cin >> b;
cout << "请输入第一个多项式的系数与指数"<
creatpoly(pa,a);
cout << "请输入第二个多项式的系数与指数"<
creatpoly(pb,b);
addpoly(pa,pb,pc);
outputpoly(pc);
cin >> b;
delete(pa);
delete(pb);
delete(pc);
return 0;
}
当然我们可以在人性化一点，加上while实现，连续操作。
实验总结：
1、刚开始编的时候，老是出现不能访问内存错，说是没有初始化，不能访问。通过查找资料发现，在开辟一个新节点时，必须给其开辟空间，在c++里面用new语句，在c中用malloc语句即可。在定义结构体指针的时候，最好给其赋值为空，谨防出现野指针的情况。
2、  多项式相加的函数中，定义了一个返回LinkList的返回值，不过一直出错，直到我把返回值去掉的时候，才不会出错，具体什么原因，我现在还不清楚。

五、一元多项式相加
文章目录
五、一元多项式相加
题目描述
解题思路
上机代码

题目描述
编写一元多项式加法运算程序。要求用线性链表存储一元多项式（参照课本）。该程序有以下几个功能：
1、多项式求和

输入：输入三个多项式，建立三个多项式链表Pa、Pb、Pc

（提示：调用CreatePolyn(polynomial &P,int m)。

输出：显示三个输入多项式Pa、Pb、Pc、和多项式Pa+Pb、多项式Pa+Pb+Pc

（提示：调用AddPolyn(polynomial &Pa, polynomial Pb), 调用PrintPolyn(polynomial P))。
0、退出
输入：
根据所选功能的不同，输入格式要求如下所示（第一个数据是功能选择编号，参见测试用例）：


1

多项式A包含的项数，以指数递增的顺序输入多项式A各项的系数（整数）、指数（整数）
多项式B包含的项数，以指数递增的顺序输入多项式B各项的系数（整数）、指数（整数）
多项式C包含的项数，以指数递增的顺序输入多项式C各项的系数（整数）、指数（整数）



0

操作终止，退出。



输出：
对应一组输入，输出一次操作的结果（参见测试用例）。


1
多项式输出格式：以指数递增的顺序输出: <系数,指数>,<系数,指数>,<系数,指数>,参见测试用例。零多项式的输出格式为<0,0>


0
无输出







测试输入
期待的输出
时间限制
内存限制
额外进程




测试用例 1
1
2
1 1 2 2
2
1 1 2 2
2
1 1 2 2
<1,1>,<2,2>
<1,1>,<2,2>
<1,1>,<2,2>
<2,1>,<4,2>
< 3,1>,<6,2>
1秒
1024KB
0


测试用例 2
1
2
6 3 8 6
2
3 4 4 8
3
1 1 5 5 9 9
<6,3>,<8,6>
< 3,4>,<4,8>
<1,1>,<5,5>,<9,9>
<6,3>,< 3,4>,<8,6>,<4,8>
<1,1>,<6,3>,< 3,4>,<5,5>,<8,6>,<4,8>,<9,9>
1秒
1024KB
0


测试用例 3
1
2
1 1 2 2
2
-1 1 -2 2
2
1 1 2 2
<1,1>,<2,2>
<-1,1>,<-2,2>
<1,1>,<2,2>
<0,0>
<1,1>,<2,2>
1秒
1024KB
0


解题思路
教材上的解法挺好，就是显得比较麻烦，需要调用的函数较多。这里我们采用链表的方式进行求解，实现三个函数即可：

构造多项式create（）
多项式相加add（）
打印多项式print()

其中多项式相加是核心，因为输入是按指数递增的顺序，所以我们只需要分三种情况进行讨论，直接求和就好。若某一个链表较长，还需要单独遍历后续结点。
还有一个要注意的点就是，零多项式的输出是<0,0>，对于零多项式也需要建立结点
上机代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
	int ax, ex;//系数、指数
	struct node *next;
}LinkNode, *LinkList;

LinkList create(int);//构造多项式
LinkList add(LinkList, LinkList);//多项式相加
void print(LinkList);//打印多项式

int main()
{
	int T = 1;
	scanf("%d", &T);
	//0为假，1为真
	if(T)
	{
		LinkList head1, head2, head3, p;

		//构造多项式
		int n=0;
		scanf("%d", &n);
		head1 = create(n);
		print(head1);

		scanf("%d", &n);
		head2 = create(n);
		print(head2);

		scanf("%d", &n);
		head3 = create(n);
		print(head3);

		//多项式相加并输出
		p = add(head1, head2);
		print(p);
		p = add(p, head3);
		print(p);
	}	
	return 0;
}

LinkList create(int n)
{
	LinkList head, q;
	int ax=0, ex=0;

	//初始化头结点
	head = (LinkList)malloc(sizeof(LinkNode));
	head->next=NULL;
	q = head;

	while(n--)
	{
		scanf("%d%d", &ax, &ex);

		//尾插法建立链表
		LinkList p = (LinkList)malloc(sizeof(LinkNode));
		p->ax = ax;
		p->ex = ex;
		p->next = NULL;

		q->next = p;
		q = p;
	}

	//如果没有输入则置0
	if(q == head)
	{
		LinkList p = (LinkList)malloc(sizeof(LinkNode));
		p->ax = 0;
		p->ex = 0;
		p->next = NULL;

		q->next = p;
		q = p;
	}

	return head;
}

LinkList add(LinkList head1, LinkList head2)
{
	/* 链表 head3 = head1 + head2 */
	//初始化头结点
	LinkList head3, ans;
	head3 = (LinkList)malloc(sizeof(LinkNode));
	head3->next = NULL;
	ans = head3;

	LinkList p, q;
	p = head1->next;
	q= head2->next;

	/* 因为输入按指数递增的顺序，直接开始求和即可, 分为三种情况讨论：
		1. p指数小于q
		2. p指数大于q
		3. p指数等于q
	*/
	while(p != NULL && q != NULL)
	{
		if(p->ex < q->ex)//p指数小于q
		{
			if(p->ax)//系数不为0才进行操作
			{
				//尾插法
				LinkList s = (LinkList)malloc(sizeof(LinkNode));
				s->ax = p->ax;
				s->ex = p->ex;
				s->next = NULL;

				ans->next = s;
				ans = s;
			}
			p = p->next;
		}
		else if(p->ex > q->ex)//p指数大于q
		{
			if(q->ax)
			{
				LinkList s = (LinkList)malloc(sizeof(LinkNode));
				s->ax = q->ax;
				s->ex = q->ex;
				s->next = NULL;

				ans->next = s;
				ans = s;
			}
			q = q->next;
		}
		else//p指数等于q
		{
			if(p->ax + q->ax)//系数求和不为0才进行操作
			{
				LinkList s = (LinkList)malloc(sizeof(LinkNode));
				s->ax = p->ax + q->ax;
				s->ex = p->ex;
				s->next = NULL;

				ans->next = s;
				ans = s;
			}
			p = p->next;
			q = q->next;
		}
	}
	//如果某一个链表较长，则需要单独遍历
	while(p != NULL)
	{
		if(p->ax)
		{
			LinkList s = (LinkList)malloc(sizeof(LinkNode));
			s->ax = p->ax;
			s->ex = p->ex;
			s->next = NULL;

			ans->next = s;
			ans = s;
		}
		p = p->next;
	}
	while(q != NULL)
	{
		if(q->ax)
		{
			LinkList s = (LinkList)malloc(sizeof(LinkNode));
			s->ax = q->ax;
			s->ex = q->ex;
			s->next = NULL;

			ans->next = s;
			ans = s;
		}
		q = q->next;
	}
	//如果求和的结果为0则置0
	if(ans == head3)
	{
		LinkList s = (LinkList)malloc(sizeof(LinkNode));
		s->ax = 0;
		s->ex = 0;
		s->next = NULL;

		ans->next = s;
		ans = s;
	}

	return head3;
}

void print(LinkList p)
{
	p = p->next;//越过头结点
	while(p->next != NULL)
	{
		printf("<%d,%d>,", p->ax, p->ex);
		p = p->next;
	}
	printf("<%d,%d>\n", p->ax, p->ex);//最后一个结点
}

【实验内容】

结合书上第41页的例子，采用链式存储结构，将两个线性链表表示的一元多项式相加，并输出。此一元多项式遵循多项式相加运算规则：对于两个一元多项式中存在指数相同的项时，其对应系数相加。合并后系数和为零时，删除“和多项式”中此项；合并后系数和不为零时，则构成“和多项式”中的一项。对于两个一元多项式中存在的指数不相同的项，则分别复抄到“和多项式”中去，原多项式保持不变。



【实验目的】

1、了解链式存储结构的基本知识；

2、掌握算法思想和数据结构的描述；

3、结合一元多项式相加的运算规则。



【实验步骤与要求】

1、实验前的准备

（1）了解C语言的基本概念；

（2）了解C语言的基本段落。

2、上机操作

（1）了解链式存储结构的基本知识；

（2）掌握算法思想和数据结构的描述；

（3）掌握一元多项式相加的运算规则。



代码：
#include<stdio.h>
#include<stdlib.h>
typedef struct Elem//多项式元素
{
    float coef;//系数
    int expn;//指数
    struct Elem *next;
}node;
typedef struct link//多项式
{
    int size;
    node *head;
}Polyn;
Polyn* CreatPolyn()//创建一个多项式
{
    Polyn *p=malloc(sizeof(Polyn));
    p->head=malloc(sizeof(node));//空的头节点
    p->size=0;
    p->head->coef=0;
    p->head->expn=-1;
    p->head->next=NULL;
    return p;
}
node* find(Polyn *p,node *t)//在多项式p中寻找当前节点合适的插入位置并返回
{
    node *d=p->head;
    while(d->next&&d->next->expn<t->expn)//当当前节点的下一个节点的指数大于等于当前待插入节点的指数时退出
    {
        d=d->next;
    }
    return d;//返回该位置
}
void add(Polyn *p,node *t)//往一个多项式中假如一个t元素
{
    node *d=find(p,t);//用find函数寻找一个合适的插入位置
    if(d->next&&d->next->expn==t->expn)//如果d->next存在并且多项式元素的指数等于当前待插入元素的指数
    {
        if(t->coef+d->next->coef==0)//如果系数相加为0，就直接删除该节点
        {
            node *temp=d->next;
            d->next=d->next->next;
            free(temp);
            p->size=p->size-1;
        }
        else//否则就修改多项式中的系数
        {
            d->next->coef=d->next->coef+t->coef;
        }
    }
    else//表示多项式中找不到与当前待插入元素的指数相同的元素，那么直接插入该位置
    {
        node *temp=malloc(sizeof(node));
        temp->next=d->next;
        temp->coef=t->coef;
        temp->expn=t->expn;
        d->next=temp;
        p->size=p->size+1;
    }
}
void print(Polyn *p)//输出多项式内容
{
    node *d=p->head->next;
    if(p->size==0)//特殊处理多项式没有项的情况
    {
        printf("0\n");
        return;
    }
    printf("%.2f",d->coef);//特殊处理第一项，为了不输出多余的加号
    if(d->expn!=0)
    {
        printf("X^(%d)",d->expn);
    }
    d=d->next;
    while(d)
    {
        printf("%+.2f",d->coef);
        if(d->expn!=0)//指数为0的时候就不用输出X了
        {
            printf("X^(%d)",d->expn);
        }
        d=d->next;
    }
    printf("\n");
}
void merge(Polyn *la,Polyn *lb)
{
    node *d=lb->head->next;
    while(d)
    {
        add(la,d);
        node *temp=d;
        d=d->next;
        free(temp);
    }
}
int main()
{
    int i,n,m;
    node t;
    Polyn *link_a=CreatPolyn();//创建一个多项式a
    printf("please input the length of a:");
    scanf("%d",&n);//输入多项式a的长度
    t.next=NULL;
    for(i=0;i<n;i++)
    {
        scanf("%f%d",&t.coef,&t.expn);//先输入每一项的系数再输入每一项的指数
        add(link_a,&t);
    }
    printf("\n");
    printf("the size of a is:%d\n",link_a->size);
    printf("the polynomial a is:");
    print(link_a);
    printf("\n");
    Polyn *link_b=CreatPolyn();
    printf("please input the length of b:");
    scanf("%d",&m);
    for(i=0;i<m;i++)
    {
        scanf("%f%d",&t.coef,&t.expn);
        add(link_b,&t);
    }
    printf("\n");
    printf("the size of b is:%d\n",link_b->size);
    printf("the polynomial b is:");
    print(link_b);
    merge(link_a,link_b);
    printf("\n");
    printf("after merging the polynomial a is:");
    print(link_a);
    free(link_a->head);
    free(link_a);
    free(link_b->head);
    free(link_b);
    return 0;
}