链表多项式

第1关：基于链表的两个一元多项式的基本运算在计算机科学中，一元多项式是常见的代数表达式形式，通常用来表示多项式函数。

虽然一元多项式的计算看似简单，但如果使用数据结构来实现，将会大大提高计算效率。

这篇文档将详细介绍基于链表的两个一元多项式的基本运算。

一元多项式的定义：在代数学中，一元多项式是一种含有一个未知数的代数多项式。

它是指一个代数式，它是由保持仅仅又有限个多项式的乘积。

此外，一元多项式在基本运算方面具有封闭性，这也是为什么它被广泛应用的原因之一。

在这里，我们将讨论在计算机科学中对一元多项式的实现。

链表的定义：链表是一种线性数据结构，其中数据元素不是常规的数组索引组织，而是通过信息存储元素之间的链来相互连接。

每个元素被称为节点，并且每个节点包含一个下一个节点的指针。

基于链表的一元多项式的实现：基于链表的一元多项式的实现涉及到将每个多项式的系数和指数存储为链表中的节点。

这种实现的主要优点是，它可以轻松地进行添加和删除操作，可以有效地分配内存，而不会浪费存储空间。

考虑到一元多项式的基本运算包括加法，减法和乘法，我们将详细介绍每种操作的实现。

一、基于链表的两个一元多项式的加法操作在实现一元多项式加法时，我们需要创建两个链表来存储两个多项式。

链表节点应该包含两个属性：系数和指数。

然后我们可以使用以下方法将两个多项式相加。

1. 定义两个指针p1和p2分别指向多项式链表的头部。

2. 定义一个新链表，用于存储相加的项。

3. 当p1和p2都不为空时循环进行以下操作：a. 如果p1当前节点的指数小于p2当前节点的指数，则将p1的节点添加到新链表中并将p1指针向下移动一个节点。

b. 如果p1当前节点的指数大于p2当前节点的指数，则将p2的节点添加到新链表中并将p2指针向下移动一个节点。

c. 如果p1和p2当前节点的指数相等，则将两个节点的系数相加，并将结果添加到新链表中，并将p1和p2指针都向下移动一个节点。

的所有剩余项添加到新链表中。

实习报告一、实习题：请写出计算两个以单链接表表示的多项式相乘的程序。

1．需求分析和说明两个多项式相乘，可以利用两个多项式的加法来实现，因为乘法运算可以分解为一系列的加法运算：C(x)=A(x)*B(x)=A(x)*(b1x+b2x2+…+b n x n)=∑=niii xbxA1)(先用其中一个多项式去乘以另一个多项式的每一项，得出的若干个多项式按照一定的顺序相加，即幂不同的按照升幂排列，幂相同的将系数相加。

例如：对于(X->1+2X->2)*(2X->2+4X->3).X->1*(2X->2+4X->3)=2X->3+4X->4;2X->2*(2X->2+4X->3)=4X->4+8X->5;排列结果：2X->3+8X-4+8X->52．设计用两个单链表的存储两个多项式，每个结点包含单项式的系数，幂和指向下一个元素地址的指针。

用其中的一个多项式乘以另一个多项式的每一项，随后将所得结果按照升幂顺序排列，最后得到结果。

存储结构：//单项式结构struct Term {float coef; // 系数。

int exp; // 幂指数。

Term( float c, int e) { coef = c; exp = e;}Term( ) { }friend int operator == (const Term & L, const Term & T ) { return L.exp == T.exp; }friend int operator > (const Term & L, const Term & T ) { return L.exp > T.exp; }friend int operator < (const Term & L, const Term & T ) { return L.exp < T.exp; }friend Term & operator += ( Term & L, const Term & T ){ L.coef += T.coef; return L; } //幂指数相同，则系数相加。

学习笔记：单链表实现多项式相乘（⼀）单链表实现多项式相乘，有这样的⼀个思路可以参考：实现多项式相乘，最关键的是系数和指数的两个数据，这⾥命名为coef和HighPower。

最简便的办法是使⽤两个嵌套循环例如(3x^2+4x^1)(x^2+2x^4)⽤3x^2遍历另外⼀个括号内的数据，同时实现本⾝括号内的遍历。

这个想法的核⼼程序可归纳为以下：while(pList!=NULL){while(pList2!=NULL){pNew=(PNODE)malloc(sizeof(NODE));pNew->pNext=NULL;pNew->coef=(pList->coef)*(pList2->coef);pNew->HighPower=(pList->HighPower)+(pList2->HighPower);pReslut=addNewItem(pReslut,pNew);pList2=pList2->pNext;}pList2=pHead2;pList=pList->pNext;}这样即可实现将所有数据，输出到⼀个新的链表⾥⾯。

但同时这也带来了不少问题，怎样才能合并新的链表⾥⾯相同系数的参数呢？这⾥可以使⽤这样的⽅法：创捷⼀个新表New,新表New2，将原有的表拆分循环复制在NEW2，然后将NEW2复制给NEW,如果在NEW中有相同项，则直接相加或者相乘，如果没有，则在链表最后添加新的节点。

这样即可实现合并单链表中相同系数的参数。

源码如下：#include<stdio.h>#include<stdlib.h>typedef struct node{int coef;int HighPower;struct node *pNext;}NODE,*PNODE;PNODE crateList();void traverseLinkList(PNODE);PNODE caculate(PNODE,PNODE);PNODE addNewItem(PNODE ,PNODE );PNODE total(PNODE);PNODE ListFind(PNODE,PNODE);int main(){PNODE pList,pList2,pNew;pList=crateList();getchar();pList2=crateList();pNew=caculate(pList,pList2);pNew=total(pNew);traverseLinkList(pNew);return(0);}PNODE crateList(){int a,b,c;PNODE pCurrent,pPre,pHead=NULL;pCurrent=NULL;pPre=NULL;b=0,c=0;while(1){if(scanf("%d %d",&b,&c)!=2)break;pCurrent=(PNODE)malloc(sizeof(NODE));if(pHead==NULL)pHead=pCurrent;elsepPre->pNext=pCurrent;pCurrent->pNext=NULL;pCurrent->coef=b;pCurrent->HighPower=c;pPre=pCurrent;}puts("input end,now next step");return(pHead);}void traverseLinkList(PNODE pList){if(pCurrent==NULL)puts("No Data Record");elsewhile(pCurrent!=NULL){printf("the Coef is %d,and HighPower is %d\n",pCurrent->coef,pCurrent->HighPower); pCurrent=pCurrent->pNext;}}PNODE caculate(PNODE pList,PNODE pList2){PNODE pNew,pCurrent,pPre,pHead2=pList2,pReslut=NULL;if(!pList||!pList2){puts("wrong!");return(0);}while(pList!=NULL){while(pList2!=NULL){pNew=(PNODE)malloc(sizeof(NODE));pNew->pNext=NULL;pNew->coef=(pList->coef)*(pList2->coef);pNew->HighPower=(pList->HighPower)+(pList2->HighPower);pReslut=addNewItem(pReslut,pNew);pList2=pList2->pNext;}pList2=pHead2;pList=pList->pNext;}return(pReslut);}PNODE addNewItem(PNODE pReslut,PNODE pAdd){PNODE pHead=NULL,pCurrent;if(pReslut==NULL){return(pAdd);}pHead=pReslut;pCurrent=pReslut;while(pCurrent->pNext!=NULL)pCurrent= pCurrent->pNext;pCurrent->pNext=pAdd;pAdd->pNext=NULL;return(pHead);}PNODE total(PNODE pNew){PNODE pNew3,pCurrent,pPre,pHead,pNew2=NULL;pCurrent=pNew;if(!pNew)return(0);pNew3=(PNODE)malloc(sizeof(NODE));pNew2=(PNODE)malloc(sizeof(NODE));pNew3->pNext=NULL;while(pCurrent!=NULL){pNew3->coef=pCurrent->coef;pNew3->HighPower=pCurrent->HighPower;pNew2=ListFind(pNew2,pNew3);if(!pHead)pHead=pNew;pCurrent=pCurrent->pNext;}return(pHead);}PNODE ListFind(PNODE pNew,PNODE pList){PNODE pCurrent,pPre,pHead,pCurrent2;while(pCurrent!=NULL){if(pCurrent->HighPower==pList->HighPower){pCurrent->coef=(pCurrent->coef)*(pList->coef);pCurrent->HighPower=pCurrent->HighPower+pList->HighPower;return(pHead);}pCurrent=pCurrent->pNext;}pCurrent=(PNODE)malloc(sizeof(NODE));if(!pHead)pHead=pCurrent;elsepPre->pNext=pCurrent;puts("ok");pCurrent->pNext=NULL;pCurrent->coef=pList->coef;pCurrent->HighPower=pList->HighPower;}。

单链表实现多项式的表⽰及运算单链表实现多项式的加法运算最近学习数据结构的线性表，有顺序存储和链表两种，多项式的表⽰和运算，最能巩固学习成果，现在提供详细代码，来实现多项式的加法运算。

多项式⽤单链表最为合适，不会造成更多的资源浪费。

如果你恰好⽤的这本书--数据结构（Java版）（第4版）（叶核亚），推荐你去下⾯这个链接下载书本源代码，将更助你学的轻松。

1//单链表类，实现⼀些基本单链表的操作2public class SinglyList<T> extends Object {3public Node<T> head; // 头指针，指向单链表的头结点45public SinglyList() {6this.head = new Node<T>();7 }89public SinglyList(T[] values) { // values数组中的值构成结点10this();11 Node<T> rear = this.head;12for (int i = 0; i < values.length; i++) {13 rear.next = new Node<T>(values[i], null);14 rear = rear.next;15 }16 }1718public boolean isEmpty() {19return this.head.next == null;20 }2122public T get(int i) {23 Node<T> p = this.head.next;24for (int j = 0; p != null && j < i; j++) {25 p = p.next;26 }27return (i >= 0 && p != null) ? p.data : null;28 }2930public void set(int i, T x) {31if (i < 0 || i > size())32throw new IndexOutOfBoundsException(i + "");33if (x == null)34throw new NullPointerException("x==null");35 Node<T> p = this.head.next;36for (int j = 0; p != null && j < i; j++) {37 p = p.next;38 }39 p.data = x;4041 }4243public int size() {44int len = 0;45 Node<T> p = this.head.next;46if (p == null)47return -1;48while (p != null) {49 len++;50 p = p.next;5152 }53return len;54 }5556public Node<T> insert(int i, T x) {57if (x == null)58throw new NullPointerException("x==null");59 Node<T> front = this.head;60for (int j = 0; front.next != null && j < i; j++) {61 front = front.next;62 }63 front.next = new Node<T>(x, front.next);64return front.next;6566 }6768public Node<T> insert(T t) {69return insert(Integer.MAX_VALUE, t);70 }7172public T remove(int i) {73 Node<T> front = this.head;74for (int j = 0; front.next != null && j < i; j++) {75 front = front.next;76 }77if (i >= 0 && front.next != null) {78 T old = front.next.data;79 front.next = front.next.next;80return old;81 }82return null;8384 }8586public void clear() {87this.head.next = null;88 }8990 }91// 排序单链表，对于⼀些结点可以实现按顺序插⼊排序92public class SortedSinglyList<T extends Comparable<? super T>> extends93 SinglyList<T> {94public SortedSinglyList() {95super();96 }9798public SortedSinglyList(T[] values) { // values的数组中的对象按值插⼊99super();100for (int i = 0; i < values.length; i++) {101this.insert(values[i]);102 }103 }104105public SortedSinglyList(SinglyList<T> list) { // 单链表的深拷贝106super();107for (Node<T> p = list.head.next; p != null; p = p.next)108this.insert(p.data);109 }110111public Node<T> insert(T x) { // 覆盖⽗类的insert⽅法112 Node<T> front = this.head, p = front.next;113while (p != null && pareTo(p.data) > 0) {114 front = p;115 p = p.next;116 }117 front.next = new Node<T>(x, p); // 在front之后，p之前插⼊x节点118return front.next;119 }120121 }122123//可相加接⼝124public interface Addible<T> {125public void add(T t); // 两元素相加126127public boolean removable(); // 删除元素128129 }130//⽐较⼤⼩接⼝131public interface Comparable<T> {132int compareTo(T obj);133134 }135136/*137 * ⼀元多项式节点类存储多项式的系数(coefficient)和指数(exponential)138*/139public class PolyNode implements Comparable<PolyNode>, Addible<PolyNode> { 140private int coef;// 系数141private int expo;// 指数142143protected PolyNode next;144145public PolyNode() {146this(0, 0);147 }148149public PolyNode(int coef, int expo) { // 带参数的构造函数150151this.coef = coef;153// this.next = null;154 }155156public PolyNode(PolyNode po) { // 拷贝构造函数157this(po.coef, po.expo);158 }159160public boolean equals(Object obj) // ⽐较两项是否相等161 {162if (this == obj)163return true;164if (!(obj instanceof PolyNode))165return false;166 PolyNode term = (PolyNode) obj;167return this.coef == term.coef && this.expo == term.expo;168 }169170public PolyNode(String str) { // 参数为⼀个项时，得到项的系数和指数171if (str.charAt(0) == '+')172 str = str.substring(1); // 去掉‘+’号173int i = str.indexOf('x');174if (i == -1) {175this.coef = Integer.parseInt(str); // 没有x,指数就为0176this.expo = 0;177 } else {178if (i == 0) { // x在开头，系数为1179this.coef = 1;180 } else {181 String str1 = str.substring(0, i);// 截取x符号之前的系数182if (str1.equals("-")) { // 为‘-’，系数为-1183this.coef = -1;184 } else {185this.coef = Integer.parseInt(str1);186 }187 i = str.indexOf('^');// 找^符号188if (i == -1)189this.expo = 1;190else191this.expo = Integer.parseInt(str.substring(i + 1));192 }193 }194 }195196public String toString() { // 显⽰多项式的样式197 String sy = this.coef > 0 ? "+" : "-";198if (this.expo == 0 || this.expo > 0 && this.coef != 1199 && this.coef != -1) {200 sy += Math.abs(this.coef); // 系数绝对值，系数为-1或1不能显⽰201 }202if (this.expo > 0)203 sy += "x";// 指数为0不能输出x204if (this.expo > 1)205 sy += "^" + this.expo;// 指数为1不能输出^206return sy;207 }208209public int compareTo(PolyNode a) { // ⽐较两项的⼤⼩210return (this.expo < a.expo ? -1 : (this.expo == a.expo ? 0 : 1)); 211 }212213public void add(PolyNode po) { // 相加214if (pareTo(po) == 0)215this.coef += po.coef;216217 }218219public boolean removable() { // 删除220return this.coef == 0;221 }222223public int getCoef() {224return coef;225 }226227public void setCoef(int coef) {228this.coef = coef;229 }230231public int getExpo() {232return expo;233 }234235public void setExpo(int expo) {237 }238239 }240/*241 * ⼀元多项式排序链表类，提供排序单链表的多项式相加运算；242*/243public class PolySort<T extends Comparable<? super T> & Addible<T>> extends244 SortedSinglyList<T> {245246public PolySort() {247super(); // 构造空单链表248 }249250public PolySort(T value[]) { // 构造⽅法，项的组来指定各项的值251super(value);252 }253254public PolySort(PolySort<T> list) {// 调⽤⽗类的深拷贝函数，复制所有结点255super(list);256 }257258// 多项式相加函数259public void addAll(PolySort<T> list) {260 Node<T> front = this.head, p = front.next;261 Node<T> q = list.head.next;262while (p != null && q != null) {263if (pareTo(q.data) == 0) { // 两项⼤⼩相同264 p.data.add(q.data);265if (p.data.removable()) { // 删除系数为0的结点266 front.next = p.next;267 p = front.next;268 } else {269 front = p;270 p = p.next;271272 }273 q = q.next;274 } else if (pareTo(q.data) < 0) {275 front = p;276 p = p.next;277 } else {278 front.next = new Node<T>(q.data, p);279 q = q.next;280 }281 }282while (q != null) // 将list单链表中剩余结点复制并插⼊到当前链表尾283 {284 front.next = new Node<T>(q.data, null);285 front = front.next;286 q = q.next;287 }288 }289290 }291// 多项式类，使⽤多项式排序单链表类作为成员变量，提供多项式相加运算292public class Polynomial {293private PolySort<PolyNode> list; // 多项式排序单链表294295public Polynomial() // 构造⽅法296 {297this.list = new PolySort<PolyNode>(); // 创建空单链表，执⾏排序单链表默认构造⽅法298 }299300public Polynomial(PolyNode terms[]) // 构造⽅法，由项数组指定多项式各项值301 {302this.list = new PolySort<PolyNode>(terms);303 }304305public Polynomial(String polystr) // 构造⽅法，参数指定多项式表达式字符串306 {307this();308if (polystr == null || polystr.length() == 0)309return;310 Node<PolyNode> rear = this.list.head;311int start = 0, end = 0; // 序号start～end的⼦串为⼀项312while (start < polystr.length() && end < polystr.length()) {313int i = polystr.indexOf('+', end + 1); // 返回字符+在字符串中从end+1开始的序号314if (i == -1) // 未找到指定字符315 i = polystr.length();316int j = polystr.indexOf('-', end + 1);317if (j == -1)318 j = polystr.length();319 end = i < j ? i : j; // end为下⼀个+或-号的序号320 rear.next = new Node<PolyNode>(new PolyNode(polystr.substring(321 start, end)), null);322// 尾插⼊，以序号start～end的⼦串作为⼀项，创建结点，创建元素对象323 rear = rear.next;324 start = end;325 }326 }327328public Polynomial(Polynomial poly) // 深度拷贝构造⽅法，复制所有结点和对象329 {330this(); // 创建空单链表，只有头结点331 Node<PolyNode> rear = this.list.head;332for (Node<PolyNode> p = poly.list.head.next; p != null; p = p.next) // p遍历poly单链表333 {334 rear.next = new Node<PolyNode>(new PolyNode(p.data), null);// 复制结点，复制对象335 rear = rear.next;336 }337 }338339public String toString() // 返回多项式的描述字符串340 {341 String str = "";342for (Node<PolyNode> p = this.list.head.next; p != null; p = p.next)343 str += p.data.toString();344return str;345 }346347public void addAll(Polynomial poly) // 多项式相加，this＋=poly348 {349this.list.addAll(poly.list);350 }351352public Polynomial union(Polynomial poly) // 加法＋，C=this＋poly353 {354 Polynomial polyc = new Polynomial(this); // 深度拷贝，复制所有结点和对象355 polyc.addAll(poly); // polyc＋=poly356return polyc; // 返回对象引⽤357 }358359public boolean equals(Object obj) // ⽐较两个多项式是否相等360 {361return this == obj || obj instanceof Polynomial362 && this.list.equals(((Polynomial) obj).list);363// ⽐较两条单链表是否相等364 }365 }366// 测试类，完成多项式的相加结果并显⽰367public class Poly extends PolySort {368369public static void main(String[] args) {370371 System.out.println("//⼀元多项式");372 PolyNode aterms[] = { new PolyNode(-7, 9), new PolyNode(2, 7),373new PolyNode(-9, 4), new PolyNode(1, 2), new PolyNode(-1, 1),374new PolyNode(2, 0) };375 Polynomial apoly = new Polynomial(aterms);376377 PolyNode bterms[] = { new PolyNode(9, 11), new PolyNode(5, 10),378new PolyNode(-3, 8), new PolyNode(10, 4), new PolyNode(-1, 2),379new PolyNode(1, 1), new PolyNode(-1, 0) };380 Polynomial bpoly = new Polynomial(bterms);381382// Polynomial bpoly = new Polynomial("-1+x-x^2+10x^4-3x^8+5x^10+9x^11");383 System.out.println("A=" + apoly.toString() + "\nB=" + bpoly.toString());384385 Polynomial cpoly = apoly.union(bpoly);386 System.out.println("C=A+B，C=" + cpoly.toString());387 apoly.addAll(bpoly);388 System.out.println("A+=B，A=" + apoly.toString());389390 }391 }。

摘要在算法程序的设计与编写过程中，根据对本题的要求分析，结合设计对象的特点，实现一元多项式的加、减、乘、除以及对多项式求导、求值的相关计算。

根据一元多项式的结构特点和运算规则。

本程序中采用了链表的存储与实现，采用链表可以很方便的对其中的结点进行插入、删除等操作。

通过链表的合并即可完成多项式的四则运算。

1 引言：1.1 待处理问题的问题背景：本题要求对从键盘上输入的任意两个一元多项式，能够分别对每个多项式进行降幂排序并输出，实现对这两个多项式的加、减、乘、除等相关运算。

在具体实现时，可采用链式存储结构将多项式中的每一项连接起来，从而表达出整个多项式，其中每一项是一个一元多项式，通过每一项系数与指数的输入设定，可以实现对整个多项式的设定，再通过建立单链表，结点来存储每一项的系数与指数，通过链表完成多项式的存储，对每个多项式分别建立一个链表，通过链表的加减乘除运算规则实现连标的合并，最终得到计算结果。

2需要完成的任务：根据题目要求，本程序需要实现对两个一元多项式的四则运算以及对多项式进行赋值求值运算、求导运算等相关计算，要求正确输出运算结果，对不满足输入要求的数据有一定的反应。

3设计：3.1核心算法的设计与说明：3.1.1 一元多项式的定义：有多个单项式的代数和就构成了多项式，一元多项式就是只含有一个变元的多项式。

所以由定义可知有n个单项式组成的一元多项式来说，它的运算是满足交换率的，所以可进行降幂排序，只需将它的所有指数相比较，然后将指数大的放前面，小的放后面即可完成排序。

3.1.2本题的核心算法：首先调用建表函数，CreatePolyn建立两个一元多项式，然后对两个一元多项式进行降幂排序，该过程的实现主要由insert（）函数实现，然后调用相应的计算函数: 加（AddPolyn）、减（SubtractPolyn）、（MultiplyPolyn）、除（DevicePolyn）、导数（Derivative）、求值（ValuePolyn）。

链表两个多项式相加与相乘的解释链表是一种数据结构，其中每个元素（称为节点）包含数据部分和一个指向下一个元素的指针。

在链表中表示多项式，每个节点包含一个系数和一个指示下一个节点在链表中的位置的指针。

多项式的每一项都存储在链表中。

对于两个多项式的相加和相乘，我们可以使用链表来表示这些操作。

1. 多项式相加：假设我们有两个多项式 P(x) 和 Q(x)，它们可以表示为链表：```cssP(x) = a_nx^n + a_n-1x^(n-1) + ... + a_1x + a_0Q(x) = b_mx^m + b_m-1x^(m-1) + ... + b_1x + b_0```多项式 P(x) 和 Q(x) 的相加可以通过简单的对应项相加来完成。

即对于每个i，我们找到 P(x) 的第 i 项和 Q(x) 的第 i 项，然后将它们相加并将结果存储在一个新的链表中。

注意，这可能会导致新的链表中的节点数少于原始链表中的节点数，因为如果某个指数在两个原始链表中都不存在，那么它就不会出现在结果链表中。

2. 多项式相乘：多项式相乘稍微复杂一些。

假设我们有两个多项式 P(x) 和 Q(x)，它们的链表表示如下：```cssP(x) = a_nx^n + a_{n-1}x^{n-1} + ... + a_1x + a_0Q(x) = b_mx^m + b_{m-1}x^{m-1} + ... + b_1x + b_0```P(x) 和 Q(x) 的相乘可以通过创建一个新的链表来完成，该链表包含所有可能的对应项乘积。

具体来说，结果链表的每个节点包含一个系数，该系数是原始链表中两个节点的系数的乘积。

对于每个 i 和 j（i 从 0 到 n，j 从 0 到m），我们将 P(x) 的第 i 项与 Q(x) 的第 j 项相乘并将结果添加到结果链表中。

注意，这可能会导致结果链表中的节点数多于原始链表中的节点数，因为每个节点可能与其它的多个节点相乘。

一元稀疏多项式以循环单链表按降幂排列一元稀疏多项式是指只含有一种未知数的多项式，并且其中大部分系数为零。

在计算机科学和数学领域，如何高效地表示和计算一元稀疏多项式一直是一个重要的问题。

循环单链表作为一种数据结构，可以很好地解决这一问题。

本文将从深度和广度两个方面来探讨一元稀疏多项式以循环单链表按降幂排列的表示方法。

一、基本概念和原理1. 一元稀疏多项式的定义一元稀疏多项式是指形如P(x)=a0x^m0 + a1x^m1 + ... + anx^mn的多项式，其中ai为系数，mi为指数。

很显然，如果某些项的系数为0，那么这些项可以被省略，从而得到一元稀疏多项式。

2. 循环单链表的定义循环单链表是一种特殊的单链表，它的最后一个节点指向头节点，从而形成一个循环。

这种数据结构可以很好地表示具有环路特性的问题，如环形队列和循环链表。

二、一元稀疏多项式的表示在计算机中，一元稀疏多项式通常以循环单链表的形式进行表示。

每个节点表示多项式的一项，节点中包含系数和指数两个信息。

按降幂排列的循环单链表可以很好地反映多项式的次序关系，从而方便进行各种运算操作。

举例来说，对于多项式P(x)=3x^5 + 2x^3 - x^2 + 4的表示，可以使用如下的循环单链表结构：1. 指数为5，系数为32. 指数为3，系数为23. 指数为2，系数为-14. 指数为0，系数为4这样，通过循环单链表的方式，可以直观地展现出多项式的结构和内容。

三、如何操作循环单链表表示的一元稀疏多项式1. 多项式的相加当需要对两个一元稀疏多项式进行相加时，可以直接对对应指数的节点进行系数相加。

如果某一项在另一个多项式中不存在，则直接将这一项插入到结果多项式的对应位置。

2. 多项式的相乘多项式的相乘需要将一个多项式的每一项依次与另一个多项式的所有项进行相乘，并将结果按指数相加合并。

这个操作需要对循环单链表进行多次插入和删除操作，而循环单链表的特性能够很好地支持这种需求。

一元多项式计算与链表概述及解释说明1. 引言1.1 概述在计算机科学和数学领域，一元多项式计算是一个重要的问题。

一元多项式是指包含一个未知数的多项式，它由各个项的系数和指数决定。

而链表作为一种常见的数据结构，具有灵活性和高效性，可以应用于各种问题的解决中。

1.2 文章结构本文将首先对一元多项式计算进行介绍，包括多项式的定义与表示方法、多项式加法运算以及多项式乘法运算。

然后，我们将详细探讨链表的概念、特点以及链表在一元多项式计算中的应用。

接下来，将通过实例演示来解释一元多项式计算，并说明链表结构在多项式计算中的优势。

最后，我们将分享解决一元多项式计算问题时相关的考虑事项与技巧，并对研究内容进行总结，并展望其可能的拓展方向。

1.3 目的本文旨在向读者介绍和解释一元多项式计算与链表之间的关系，并探讨链表在该问题中所起到的作用。

通过深入了解一元多项式及其计算方法，以及链表数据结构原理和应用场景，读者将能够更好地理解一元多项式的计算过程，并了解链表在提高计算效率和灵活性方面的重要作用。

同时，通过分享解决问题时的考虑事项与技巧，本文还有助于读者在实际应用中更好地利用链表结构来解决一元多项式计算问题。

2. 一元多项式计算：2.1 多项式定义与表示方法:一元多项式是由若干个单项式构成的代数表达式。

一个单项式由系数和指数组成，通常可以表示为a*x^b的形式，其中a为系数，x为未知数，b为指数。

而一个多项式则是由多个单项式相加得到。

在计算机中，可以用数组或链表来表示一元多项式。

使用数组时，每个元素可以存储一个单项式的系数和指数；而使用链表时，则可以将每个单项式作为节点存储在链表中。

2.2 多项式加法运算:两个多项式相加时，需要将同一个指数的单项式进行合并并对系数进行相加。

具体步骤如下：- 将两个多项式中所有的不同指数提取出来形成一个集合。

- 遍历集合中的每个指数，在两个多项式中查找该指数对应的单项式。

- 如果某个多项式不存在该指数的单项式，则该指数对应的系数为空。

数据结构一元多项式的运算数据结构一元多项式的运算简介一元多项式是数学中常见的概念，用于表示一个变量的多项式表达式。

在计算机科学中，经常需要对一元多项式进行各种运算，如加法、减法、乘法等。

为了实现这些运算，可以使用数据结构来存储和操作一元多项式。

本文将介绍一元多项式的数据结构和常见的运算方法，并给出相应的代码示例。

数据结构一元多项式可以用链表来表示。

每个节点包含两个部分：系数（coefficient）和指数（exponent）。

系数表示该项的权重，指数表示该项的幂次。

链表的每个节点按照指数的升序排列。

以下是一个一元多项式的链表表示的示例：```markdown1.2x^2 + 3.7x^4 - 0.5x^3 -2.1x^1 + 4.0``````markdownNode 1: coefficient=1.2, exponent=2Node 2: coefficient=3.7, exponent=4Node 3: coefficient=-0.5, exponent=3Node 4: coefficient=-2.1, exponent=1Node 5: coefficient=4.0, exponent=0```运算方法加法运算两个一元多项式相加可以按照如下步骤进行：1. 遍历两个链表的节点，分别取出当前节点的系数和指数。

2. 如果两个节点的指数相等，将系数相加，并将其作为结果链表的节点。

3. 如果两个节点的指数不相等，将指数较小的节点插入结果链表，并继续遍历指数较大的节点。

4. 当其中一个链表遍历完后，直接将另一个链表的节点插入结果链表。

以下是加法运算的代码示例：```pythondef addPolynomials(p1, p2):result = Nonetl = Nonewhile p1 is not None and p2 is not None:if p1.exponent == p2.exponent:coef_sum = p1.coefficient + p2.coefficient if coef_sum != 0:node = Node(coef_sum, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextp2 = p2.nextelif p1.exponent > p2.exponent:node = Node(p1.coefficient, p1.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextelse:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextwhile p1 is not None:node = Node(p1.coefficient, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextwhile p2 is not None:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextreturn result```减法运算减法运算可以看作加法运算的特殊情况，即将第二个多项式的系数取负数，再进行加法运算。

#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<math.h>#define ERROR 0#define POLY sizeof(Polynomial)typedef struct Polynomial /*用单链表存储多项式的结点结构*/{int coef; /*多项式的系数*/int exp; /*指数*/struct Polynomial *next;/*next是struct Polynomial类型中的一个成员，它又指向struct Polynomial类型的数据，以此建立链表*/}Polynomial;Polynomial * CreatPolyn(void)/*指针函数，返回指针类型；用尾插法建立一元多项式的链表的函数*/{Polynomial *head,*tail,*s;int c,e;head=(Polynomial *)malloc(POLY);/*建立多项式的头结点，为头结点分配存储空间*/if(!head)exit(ERROR);tail=head;/*tail指针始终动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/ printf("系数:");scanf("%d",&c); /*输入系数*/printf("指数: ");scanf("%d",&e); /*输入指数*/if(c==0){printf("请重新输入");return NULL;}else{while(c!=0) /*输入系数为0时，表示多项式的输入结束*/{s=(Polynomial *) malloc(POLY); /*申请新结点*/s->coef=c; /*申请新结点后赋值*/s->exp=e; /*申请新结点后赋值*/tail->next=s; /*做尾插，插入新结点*/tail=s; /*tail始终指向单链表的表尾*/printf("系数:");scanf("%d",&c);printf("指数: ");scanf("%d",&e);}tail->next=NULL; /*将表的最后一个结点的next置NULL，以示表结束*/ return(head);}}void DestroyPolyn(Polynomial *p)//删除多项式{Polynomial *q;while(p->next!=NULL){q=p->next;free(p);p=q;}}int PolyLength(Polynomial *p){Polynomial *q;int i=0;q=p;while(q->next!=NULL){q=q->next;i++;}return(i);}void Order(Polynomial *p)/*多项式的升幂排序*/{Polynomial *q;int a,b,i=0;q=p;while(q->next!=NULL){if(q->exp>q->next->exp){a=q->coef;b=q->exp;q->coef=q->next->coef;q->exp=q->next->exp;q->next->coef=a;q->next->exp=b;}q=q->next;i++;}}void PaiXu(Polynomial *p)//重复调用升幂排序函数{int j;for(j=1;j<PolyLength(p);j++)Order(p);}void AddPolyn(Polynomial *polya, Polynomial *polyb)/*两个一元多项式相加，将和多项式存放在多项式polya中，并将多项式ployb删除*/ {Polynomial *p,*q,*he,*temp;int sum;p=polya->next;/*令p指向polya多项式链表中的第一个结点*/q=polyb->next;/*令q指向polyb多项式链表中的第一个结点*/he=polya; /*令he指向和多项式polya*/while(p!=NULL&&q!=NULL)/*当两个多项式均未扫描结束时，执行以下操作*/{if(p->exp<q->exp)/*若p指向的多项式指数小于q指的指数*/{he->next=p; /*将p结点加入到和多项式中*/he=he->next;p=p->next; /*将p指针后移一位*/}else if(p->exp==q->exp)/*若指数相等，则相应的系数相加*/{sum=p->coef+q->coef;if(sum!=0) /*系数和不为零，执行下列操作*/{p->coef=sum;he->next=p;he=he->next;p=p->next;temp=q->next;free(q);//q=q->next;q=temp; /*释放原q节点*/}else /*系数和为零，则删除结点p与q，并将指针指向下一个结点*/{temp=p->next;free(p);p=temp;temp=q->next;free(q);q=temp;}}else /*若p指数大于q指数*/{he->next=q; /*p结点不动，将q结点加入到和多项式中*/he=he->next;q=q->next;}}if(p!=NULL)/*多项式A中还有剩余，则将剩余的结点加入到和多项式中*/he->next=p;else /*否则将B的结点加入到和多项式中*/he->next=q;}void PrintPolyn(Polynomial *p) /*输出函数，打印出一元多项式*/{p=p->next;if(p->exp>0)printf("A(x)= %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf("A(x)= %d*x^(%d)",p->coef,p->exp);elseprintf("A(x)= %d",p->coef);while(p->next!=NULL){p=p->next;if(p->coef>0){if(p->exp>0)printf(" + %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf(" + %d*x^(%d)",p->coef,p->exp);elseprintf(" + %d",p->coef);}else{if(p->exp>0)printf(" %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf(" %d*x^(%d)",p->coef,p->exp);elseprintf(" %d",p->coef);}}}void main() /*主函数*/{Polynomial *polya,*polyb;int i;printf(" !!两个多项式的相加!!");//printf("若输入的单项式为0，则表明多项式创建完毕\n");begin: printf("\n\t\t** ** ** ** ** ** * *** *** **");printf("\n\t\t* 1、输入第一个多项式 *");printf("\n\t\t* 2、输入第二个多项式 *");printf("\n\t\t* 3、输出两个多项式的和 *");printf("\n\t\t* 4、退出 *");printf("\n\t\t** ** ** ** ** ** * *** *** **");printf("\n请选择：");scanf("%d",&i);switch(i){case 1:printf("\n请输入多项式中的每一个单项式的系数和指数\n");printf(" 若输入的单项式为0，则表明多项式创建完毕:\n\n");polya=CreatPolyn(); /*调用函数，创建多项式*/if(polya==NULL)goto begin;else{PaiXu(polya);printf("输入的多项式:\n");PrintPolyn(polya);goto begin;}case 2:printf("\n请输入多项式中的每一个单项式的系数和指数:\n"); polyb=CreatPolyn(); /*同理，创建B*/if(polyb==NULL)goto begin;else{PaiXu(polyb);printf("输入的多项式:\n");PrintPolyn(polyb);goto begin;}case 3:printf("\n两个多项式的和为:\n");AddPolyn(polya,polyb); /*调用一元多项式相加函数*/PrintPolyn(polya);DestroyPolyn(polya);goto begin;case 4:printf("08计（3）谢世伟 080201031025\n");break;}}#include <cstdlib>#include <iostream>using namespace std;struct xiang{float xs,zs,x; //分别表示系数、指数、以及Xxiang *next;};class duoxiangshi{private:xiang *first,*p;public:duoxiangshi();~duoxiangshi();void add(float xs,float zs); //n代表多项式的项数个数xiang * operator+(const duoxiangshi & b); //重载多项式的相加xiang * operator-(const duoxiangshi & b);void print(xiang *athead); //输出多项式相加结果void printself(); //看一下};duoxiangshi::duoxiangshi(){first=new xiang;first->next=NULL;p=first;}duoxiangshi::~duoxiangshi(){while(p=first){first=first->next;delete p;}}void duoxiangshi::add(float xs,float zs) //增加多项式的项数，在插入的同时给它由指数的大小进行排序{xiang *q=new xiang;xiang *tmp; //临时指针。

多项式的链表表示及运算实验报告
一、实验目的
本次实验旨在了解多项式的链表表示及运算，学习应用链表实现多项式的加减乘除运算。

二、实验原理
多项式是数学中一种常见的运算方式，它由若干个单项式（即常数、未知数以及未知数不同次幂的积）求和组成。

多项式通常可以用数组或链表来表示。

本实验采用链表表示多项式。

链表表示多项式可以用一个链表来存储多项式中的每一项，链表节点存储着每一项的系数和指数。

链表的头节点指向第一项。

在链表表示多项式时，我们可以定义一个结构体来表示节点，包含两个成员变量：系数和指数。

当我们对多项式进行加减乘除运算时，首先需要将多项式转换成链表形式，然后按照运算规则进行运算，最后将运算结果转换为多项式形式。

三、实验步骤
1、定义多项式节点结构体，包含系数和指数两个成员变量；
2、编写函数从命令行读取用户输入的多项式，按照指数降序的方式将多项式转换成链表形式；
3、编写函数完成多项式相加、相减、相乘、相除等运算，每种运算均需要将两个多项式转换成链表形式后进行；
4、编写函数将链表形式的多项式转换成多项式字符串；
5、在主函数中调用上述函数，进行多项式的读取、运算、转换并输出结果。

四、实验总结
本次实验学习了多项式的链表表示及运算，掌握了链表的基本操作，了解了多项式的四则运算的实现。

在实验中，我们成功地用链表实现了多项式的加减乘除运算，实现了从命令行读取多项式，并将其转换为链表，最后将链表转换为多项式字符串输出。

通过本次实验，我更加深刻地理解了链表及其应用，学会了运用链表实现算法，提高了编码能力。

数据结构实验报告实验题目：基于链式存储的一元n次多项式相乘实验内容及要求：从字符文件输入两个多项式的非零系数及对应的指数，建立多项式的链式存储结构，计算这两个多项式的乘积，输出乘积多项式的全部非零系数及对应的指数到另一字符文件中。

要求输入输出字符文件中的数据格式自拟；编程语言采用C/C++。

实验目的：掌握单向链表的基本操作以及基于链表的多项式加法与乘法。

数据结构设计简要描述：把指数和系数放入到结构体数据类型中，采用单向链表将多项式的非零系数和指数连接起来，构成一个一元n次多项式。

算法设计简要描述：采用插入法构造有序链表，多项式相乘时，先依次用一个链表中的每个结点与另一个链表中的每一个相乘，相乘的结果按升序排序插入到第三个链表中，然后合并指数相同的结点，得到最终的多项式相乘的结果。

输入/输出设计简要描述：在文本文件中输入数据，格式为：系数，指数构造的两个一元n次多项式在运行窗口中输出，输出格式为：y = a0*pow(x,0) + a1*pow(x,1) + a2*pow(x,2) +...+ an*pow(x, n) 两个多项式相乘的结果也在运行窗口中输出，输出格式如上，同时将系数和指数保存到文件中。

保存格式为：（系数，指数）编程语言说明：使用Visual C++编程，编程语言为C语言。

动态分配内存采用malloc和free函数实现。

文件输入输出采用fscanf函数和fprintf函数实现。

DOS窗口的输入输出采用gets函数和printf函数实现。

注释采用c/c++规范。

主要函数说明：void prt(LinkList h) //输出线性单向链表LinkList create(LinkList h) //构造链表函数LinkList clear(LinkList h) //清空链表并释放空间函数LinkList mulList(LinkList ha,LinkList hb,LinkList hc) //两个多项式相乘，将结果放入hc中LinkList delRepeat(LinkList h) //合并同类项函数void writeFile(LinkList h) //将链表结点写入文件程序测试简要报告：在文件1中输入数据：文件2中输入数据：运行结果为：第一个文件名是存储第一个链表的结点数据的文件第二个文件名是存储第二个链表的结点数据的文件输入的第三个文件名是存放对象时相乘结果的数据文件源程序代码：#include<stdio.h>#include<stdlib.h>#include<malloc.h>//线性表的结构typedef int ElemType;//将ElemType约定为整数类型typedef struct node{ElemType x;ElemType z;struct node *next;}LNode ,*LinkList;typedef enum {ERROR,OK} Status;//将Status约定为枚举类型#define CreateNode(p) p=(LinkList)malloc(sizeof(LNode))#define DeleteNode(p) free((void *)(p))int n = 0;//输出线性单向链表void prt(LinkList h){LinkList p;p=h; //p指向第1个数据结点int num=0;if(h == NULL){printf("NULL List!\n"); return;}printf("y = ");while(p != NULL){num++;if(num == n)printf("%d*pow(x,%d)", p->x,p->z);elseprintf("%d*pow(x,%d) + ", p->x,p->z);p=p->next;}printf("\n\n");}LinkList create(LinkList h){LinkList p,q,newNode;FILE *fp;p = h;n = 0;char str[20];printf("Please input file name: ");gets(str);fp = NULL;if((fp = fopen(str,"r"))==NULL){printf("Can not open the file!\n");exit(0);}//while(!feof(fp))while(1){CreateNode(newNode);fscanf(fp,"%d,%d",&newNode->x,&newNode->z);if(feof(fp)){free(newNode);//读取文件数据失败（文件末尾）时退出循环break;}if(newNode->x == 0){free(newNode);//系数为0时读取下一组数据，舍弃值为0的系数continue;}p = h;n++;if(h == NULL)//链表为空时插入的结点为头结点{h = newNode; newNode->next = NULL;}else{while((newNode->z > p->z) && (p->next != NULL)) //插入的位置不当时遍历{q = p; p = p->next; }if(newNode->z <= p->z)//找到合适位置{if(h == p)//找到的位置为头结点h = newNode;q->next = newNode;//找到的位置为中间结点newNode->next = p;}else//找到的位置为尾结点{p->next = newNode; newNode->next = NULL;}}}fclose(fp);return (h);}//释放链表LinkList clear(LinkList h){LinkList p,q;p=h;h=NULL;while(p){q=p;p=p->next;DeleteNode(q);}return(h);}//多项式相乘LinkList mulList(LinkList ha,LinkList hb,LinkList hc){LinkList pa,pb,p,q,newNode;//FILE *fp;pa = ha;pb = hb;n = 0;while(pa){pb = hb;while(pb){p = hc;CreateNode(newNode);newNode->x = pa->x * pb->x;newNode->z = pa->z + pb->z;//printf("newNode->x = %d\tnewNode->z = %d\n",newNode->x,newNode->z);//将新结点插入到链表hcif(hc == NULL)//链表为空时插入的结点为头结点{hc = newNode; newNode->next = NULL;}else{while((newNode->z > p->z) && (p->next != NULL)) //插入的位置不当时遍历{q = p; p = p->next;}if(newNode->z <= p->z)//找到合适位置if(hc == p)//找到的位置为头结点{hc = newNode; newNode->next = p;}else{q->next = newNode;//找到的位置为中间结点newNode->next = p;}}else//找到的位置为尾结点{p->next = newNode; newNode->next = NULL;}}//pb遍历pb = pb->next;n++;}//pa遍历pa = pa->next;}return hc;}//合并同类项LinkList delRepeat(LinkList h){LinkList p1,p2;if(h == NULL){printf("\nNULL List!\n");return (h);}p1 = h;while(p1){p2 = p1;p1 = p1->next;if(p1 == NULL)return(h);if((p1->z == p2->z)&&(p1->next != NULL)){p2->x = p2->x + p1->x;p2->next = p1->next;free(p1);p1 = h;n--;}}return (h);}//将链表的结点数据写入文件void writeFile(LinkList h){LinkList p;FILE *fp;p=h;//p指向第1个数据结点char str[20];printf("Please input file name: ");gets(str);if((fp = fopen(str,"w+"))==NULL){printf("Can not open the file!\n");exit(0);}if(h == NULL){printf("NULL List!\n"); return;}while(p != NULL){fprintf(fp,"(%d,%d)\n",p->x,p->z);p = p->next;}fclose(fp);}int main(){LinkList List1 = NULL,List2 = NULL,List3 = NULL;List1 = create(List1);printf("The List1:");prt(List1);List2 = create(List2);printf("The List2:");prt(List2);List3 = mulList(List1,List2,List3);List3 = delRepeat(List3);printf("相乘的结果为: ");prt(List3);writeFile(List3);clear(List1);clear(List2);clear(List3);return 0;}。

单链表多项式实验报告的心得体会单链表多项式实验报告的心得体会课程学习小组讨论记录表时间周一主讲人提出问题：单链表中间有没有元素会不会影响运算结果？问题解答：这种情况确实可能发生。

所以必须对整个表进行移位。

首先把左边的表移到最后，右边的表移到最前面。

因为两个表的第一行不重合，所以需要利用到逆运算。

可是在学习的过程中会遇到很多问题，让你防不胜防。

今天我们在理解单链表之后，如何对单链表进行操作。

我认为只有我们掌握了它的知识之后，才能更好地解决一些相关的问题。

这节课的学习让我受益匪浅，从而也明白了许多道理。

这节课主要学习了单链表的知识。

为了加深同学们对单链表的认识和理解，以及对一些重点内容的掌握，对一些基础性的概念进行归纳和总结。

并且给出了一些具体的应用，便于同学们去实际的运用。

下面就让我们来总结一下本节课的内容吧！我认为，本节课学习的内容，都是非常基础的知识，然而正是因为这些基础性的东西，在解决很多实际问题时，我们却总是无从下手。

这就说明我们平时基础性的东西掌握得还不够牢固，需要花更多的时间去巩固，再去积累。

这样才能熟练的掌握知识，提高解决问题的能力。

希望通过这次的学习，我能对单链表有更加深刻的认识和理解，将来能运用所学到的知识来解决相关的问题，为我国的科研事业做出自己的贡献。

单链表4、一些特殊形式的单链表，使用时需要注意它与普通单链表的区别。

1、一些特殊形式的单链表，使用时需要注意它与普通单链表的区别。

单链表的存储结构都采用链式存储，即用单链表来存储结点的存储方式。

链表具有存储效率高的优点，但是由于结点是链式存储，导致当结点个数N较大时，容易造成结点的相互干扰和产生结点过多时，表头指针频繁移动，查找结点时很费时间，特别是指针移动到下一个结点时，计算机会感到无法处理而强制终止执行。

我们可以利用单链表表头指针所指向的元素（即索引）来判断是否是下一个结点。

这样就大大减少了指针的移动次数，查找起来就快了。

《程序设计》实习报告一、[实习报告]设一元多项式的一个项可以用整数数组的2个元素来表示：我们可以利用数组来表示一个一元多项都不会超过十项3x9-6x4+2x+7可表示为:设每个一元多项式项数都不会超过十项。

编写程序实现如下功能：①在键盘上键入指数ne和系数nf,分别生成两个一元多项式HA和HB；②输出一元多项式HA和HB;③把一元多项式HA和HB相加，生成新的一元多项式HC（HC可能超过十项）；④输出新形成的一元多项式HC（原HA和HB不变）；⑤询问“Continue(n).”当输入回答字符’n’时结束，否则回到第①点继续执行。

注意：①进行多项式相加时，只有该两项的指数相同时才能相加，若相加后系数为0，则取消该项。

②建立多项式，可以严格按指数从大到小的次序输入，此时当发现当前项的指数比前一项的指数大时，则要求重新输入；③若建立多项式时可以不按指数有大到小次序输入时，则应在输入结果后用程序调整，使数组内多项式各项依指数从大到小次序存放；④在一个多项式中若发现有两项（或两项以上）的指数相等时，应进行合并，或合并后系数为0则取消该项；⑤多项式输出形式：设有多项式3X8-2X+7，则输出形式为：3X^8-2X^1+7X^0或3X8-2X1+7X0[进一步要求]:依链表形式，编程实现上述功能。

*备注：该实习报告采用”链表形式”。

二、[解题的基本算法]由于采用链表的方法，我们可以建立3条链；一条用于存放多项式HA，一条用于存放多项式HB，还有一条用于存放新形成的HC。

此外，我们的程序应具备以下几个功能：建立链表，撤销链表，打印链表，按要求插入一个新的结点，复制链表；为了使上面程序结构分析进一步细化，为了使程序结构更加清晰，我们可以把上面的内容都编写成函数形式。

1、建立链表该程序建立链表的函数与大多数建立链表的操作基本一致，但是由于实体是一元多项式的关系。

我们更希望，在处理客户输入的数据的同时，能对数据进行适当的处理。