数据结构(Java版)线性表的实现和应用完整版

完美WORD格式专业整理知识分享数据结构线性表的实现和应用（数据结构课程上机）实验报告专业:班级:学号:姓名:成绩:实验名称线性表的实现及应用实验地点实验时间实验目的：理解用顺序表实现线性表的特点；熟练掌握顺序表的基本操作；学会利用顺序表解决实际应用问题。熟练掌握单链表的使用；理解用链表实现线性表的特点；了解链表的多种形式；学会利用单链表解决实际应用问题。实验要求：学时为8学时；能在机器上正确、调试运行程序；本实验需提交实验报告；实验报告文件命名方法：数据结构实验_信管16xx_学号_姓名.doc。实验内容和步骤：第一部分顺序表的实现与应用（1）基于顺序表实现线性表的以下基本操作：publicinterfaceLList<T>{//线性表接口，泛型参数T表示数据元素的数据类型booleanisEmpty();//判断线性表是否空intsize();//返回线性表长度Tget(inti);//返回第i（i≥0）个元素voidset(inti,Tx);//设置第i个元素值为xvoidinsert(inti,Tx);//插入x作为第i个元素voidinsert(Tx);//在线性表最后插入x元素Tremove(inti);//删除第i个元素并返回被删除对象intsearch(Tkey);//查找，返回首次出现的关键字为key的元素的位序voidremoveAll();//删除线性表所有元素publicStringtoString();//返回顺序表所有元素的描述字符串，形式为“（，）”}要求：实现后应编写代码段对每个基本操作做测试。（2）顺序表的简单应用运用基本操作编写算法删除第i个开始的k个元素。编写高效算法删除第i个开始的k个元素。将两个顺序表合并为一个顺序表（表中元素有序）；若两个元素按值递增有序排列的顺序表A和B，且同一表中的元素值各不相同。试构造一个顺序表C，其元素为A和B中元素的交集，且表C中的元素也按值递增有序排列；（3）利用顺序表解决约瑟夫环问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。要求：输出出列次序。第二部分单链表的实现与应用（4）基于单链表实现线性表的以下基本操作（不需要建立接口，直接建立带头结点的单链表类）：ADTList<T>{ booleanisEmpty();//判断线性表是否空intsize();//返回线性表长度Tget(inti);//返回第i（i≥0）个元素voidset(inti,Tx);//设置第i个元素值为xNode<T>insert(inti,Tx);//插入x作为第i个元素Node<T>insert(Tx);//在线性表最后插入x元素Tremove(inti);//删除第i个元素并返回被删除对象voidremoveAll();//删除线性表所有元素Node<T>search(Tkey);//查找，返回首次出现的关键字为key元素publicStringtoString();//返回顺序表所有元素的描述字符串，形式为“（，）”}要求：实现后应编写代码段对每个基本操作做测试。（5）实现单链表的子类排序单链表，覆盖单链表如下方法：voidset(inti,Tx);//设置第i个元素值为xNode<T>insert(inti,Tx);//插入x作为第i个元素Node<T>insert(Tx);//在线性表最后插入x元素Node<T>search(Tkey);//查找，返回首次出现的关键字为key元素（6）基于排序单链表实现线性表的以下综合应用：删除第i个开始的k个元素。删除递增有序单链表中所有值大于mink且小于maxk的元素。将两个单链表合并为一个单链表，保持有序。若两个元素按值递增有序排列的单链表A和B，且同一表中的元素值各不相同。试构造一个单链表C，其元素为A和B中元素的交集，且表C中的元素也按值递增有序排列。要求利用原有链表中的元素。（7）一元多项式的基本运算用排序单链表表示一元多项式，并实现以下基本运算：一元多项式的建立一元多项式的减法运算（要求：在运算过程中不能创建新结点即A=A-B）（8）备份自己程序实验准备：复习教材第2章线性表的知识点熟悉Java编程环境提前熟悉实验内容，设计相关算法实验过程：第一部分：（1）packageex1;publicinterfaceLList<T>{ //线性表接口，泛型参数T表示数据元素的数据类型booleanisEmpty();//判断线性表是否空intlength();//返回线性表长度Tget(inti);//返回第i（i≥0）个元素voidset(inti,Tx);//设置第i个元素值为xintinsert(inti,Tx);//插入x作为第i个元素intappend(Tx);//在线性表最后插入x元素Tremove(inti);//删除第i个元素并返回被删除对象voidremoveAll();//删除线性表所有元素intsearch(Tkey);//查找，返回首次出现的关键字为key的元素的位序}类名：publicclassSeqList<T>implementsLList<T>{ protectedObject[]element; protectedintn; publicSeqList(intlength)//构造容量为length的空表{this.element=newObject[length];//申请数组的存储空间，元素为null。//若length<0，Java抛出负数组长度异常java.lang.NegativeArraySizeExceptionthis.n=0;}publicSeqList()//创建默认容量的空表，构造方法重载{this(64);//调用本类已声明的指定参数列表的构造方法}publicSeqList(T[]values)//构造顺序表，由values数组提供元素，忽略其中空对象{this(values.length*2);//创建2倍values数组容量的空表//若values==null，用空对象调用方法，Java抛出空对象异常NullPointerExceptionfor(inti=0;i<values.length;i++)//复制非空的数组元素。O(n)if(values[i]!=null)this.element[this.n++]=values[i];//对象引用赋值} publicbooleanisEmpty()//判断线性表是否空 { returnthis.n==0; } publicintlength(){//返回线性表长度 returnthis.n; } publicTget(inti){//返回第i（i≥0）个元素 if(i>=0&&i<this.n) return(T)this.element[i];//返回数组元素引用的对象，传递对象引用// returnthis.element[i];//编译错，Object对象不能返回T对象 returnnull; } publicvoidset(inti,Tx){//设置第i个元素值为x if(x==null) thrownewNullPointerException("x==null");//抛出空对象异常 if(i>=0&&i<this.n) this.element[i]=x; elsethrownewjava.lang.IndexOutOfBoundsException(i+"");//抛出序号越界异常 } publicintinsert(inti,Tx){//插入x作为第i个元素 if(x==null) thrownewNullPointerException("x==null");//抛出空对象异常 if(i<0)i=0;//插入位置i容错，插入在最前 if(i>this.n)i=this.n;//插入在最后 Object[]source=this.element;//数组变量引用赋值，source也引用element数组 if(this.n==element.length)//若数组满，则扩充顺序表的数组容量 { this.element=newObject[source.length*2];//重新申请一个容量更大的数组 for(intj=0;j<i;j++)//复制当前数组前i-1个元素 this.element[j]=source[j]; } for(intj=this.n-1;j>=i;j--)//从i开始至表尾的元素向后移动，次序从后向前 this.element[j+1]=source[j]; this.element[i]=x; this.n++; returni;//返回x序号 } publicintappend(Tx){//在线性表最后插入x元素 returnthis.insert(this.n,x); } publicTremove(inti){ //删除第i个元素并返回被删除对象 if(this.n>0&&i>=0&&i<this.n) { Told=(T)this.element[i];//old中存储被删除元素 for(intj=i;j<this.n-1;j++) this.element[j]=this.element[j+1];//元素前移一个位置 this.element[this.n-1]=null;//设置数组元素对象为空，释放原引用实例 this.n--; returnold;//返回old局部变量引用的对象，传递对象引用 } returnnull; } publicvoidremoveAll(){ //删除线性表所有元素 this.n=0; } publicintsearch(Tkey){//查找，返回首次出现的关键字为key的元素的位 System.out.print(this.getClass().getName()+".indexOf("+key+")，"); for(inti=0;i<this.n;i++) { if(key.equals(this.element[i]))//执行T类的equals(Object)方法，运行时多态 returni; } return-1; }publicStringtoString(){ Stringstr=this.getClass().getName()+"(";//返回类名if(this.n>0)str+=this.element[0].toString();//执行T类的toString()方法，运行时多态for(inti=1;i<this.n;i++)str+=","+this.element[i].toString();//执行T类的toString()方法，运行时多态returnstr+")";}publicstaticvoidmain(Stringargs[]) { SeqList<Integer>list=newSeqList<Integer>(20); Integervalues[]={10,1,2,3,4,5,6,7,8,9}; SeqList<Integer>list1=newSeqList<Integer>(values); System.out.print("输出顺序表:"); System.out.println(list1.toString()); System.out.println("顺序表List是否为空"+list.isEmpty()+",List1是否为空"+list1.isEmpty()); System.out.println("list的长度"+list.length()+",list1的长度"+list1.length()); System.out.println("返回list1的第7个元素是:"+list1.get(6)); System.out.println("重新设置第5个元素为19:"); list1.set(4,19); list1.insert(2,100); list1.append(20); System.out.println("删除8:"+list1.remove(8)); System.out.print("修改后的顺序表:"); System.out.println(list1.toString()); list1.removeAll(); System.out.println("删除后的顺序表："+list1.toString());//为空 System.out.println("寻找元素50:"+list1.search(50)); }}（2）a)packageex1;publicclassDel{publicDel(inti,intk){ Stringvalues[]={"A","b","C","d","e","f","g","h"}; intn=values.length; for(intj=0;j<n;j++){ System.out.print(values[j]+"");} System.out.println(); for(intj=i+k;j<n;j++){ values[j-k]=values[j];} n=n-k; for(intj=0;j<n;j++){ System.out.print(values[j]+"");} System.out.println();}publicstaticvoidmain(Stringargs[]){ newDel(2,3); }}b)packageex1;publicclassDel2{publicDel2(inti,intk){ Stringvalues[]={"A","x","y","y","b","c","h"};SeqList<String>list=newSeqList<String>(values);System.out.println(list.toString());for(intj=1;j<=k;j++){list.remove(i);}System.out.println(list.toString());}publicstaticvoidmain(Stringargs[]){ newDel2(2,3);}}c)packageex1;publicclassMerge{publicMerge(){ Integervalues1[]={1,3,5,11}; SeqList<Integer>list1=newSeqList<Integer>(values1); Integervalues2[]={2,4,5,22,23}; SeqList<Integer>list2=newSeqList<Integer>(values2); SeqList<Integer>list3=newSeqList<Integer>(); inti=0,j=0; while(i<list1.length()&&j<list2.length()) { if(list1.get(i)<list2.get(j)){ list3.append(list1.get(i)); i++; } else{ list3.append(list2.get(j)); j++; } } while(i<list1.length()){ list3.append(list1.get(i)); i++; } while(j<list2.length()) { list3.append(list2.get(j)); j++; } System.out.println(list1.toString()); System.out.println(list2.toString()); System.out.println(list3.toString()); }publicstaticvoidmain(Stringargs[]){ newMerge(); }}d)packagetest;importex1.SeqList;publicclassIntersection{ publicIntersection(){ Integervalues1[]={1,3,5,11,12,13,22,23,50}; SeqList<Integer>list1=newSeqList<Integer>(values1); Integervalues2[]={2,4,5,12,19,20,22,23,}; SeqList<Integer>list2=newSeqList<Integer>(values2); SeqList<Integer>list3=newSeqList<Integer>(); inti=0,j=0; while(i<list1.length()&&j<list2.length()) { if(list1.get(i)<list2.get(j)){ i++; } elseif(list1.get(i)>list2.get(j)){ j++; } else {list3.append(list1.get(i)); i++; j++; } } System.out.println(list1.toString()); System.out.println(list2.toString()); System.out.println(list3.toString()); } publicstaticvoidmain(Stringargs[]) { newIntersection(); }}3.（1）packageex1;publicclassJosephus{ publicJosephus(intn,intk,intm) { System.out.println("Josephus("+n+","+k+","+m+")，"); SeqList<String>list=newSeqList<String>(n); //创建顺序表实例，元素类型是数字字符，只能排到n=9,否则达不到效果 for(inti=0;i<n;i++) list.append((char)('1'+i)+"");//顺序表尾插入，O(1) //System.out.println(list.toString());//输出顺序表的描述字符串，O(n) inti=k;//计数起始位置 while(list.length()>1)//多于一个元素时循环，计数O(1) { i=(i+m-1)%list.length();//按循环方式对顺序表进行遍历,圆桌循环 System.out.print("出列"+list.remove(i).toString()+"，");//删除i位置对象，O(n) //System.out.println(list.toString()); } System.out.println("出列"+list.get(0).toString());//get(0)获得元素，O(1) } publicstaticvoidmain(Stringargs[]) { newJosephus(9,1,3); } }（2）packagetest;importex1.SeqList;publicclassJosephusA{ publicJosephusA(intn,intk,intm) { System.out.println("Josephus("+n+","+k+","+m+")，"); SeqList<Integer>list=newSeqList<Integer>(n); //创建顺序表实例，元素类型是数字字符，只能排到n=9,否则达不到效果 for(inti=0;i<n;i++) list.append(i);//顺序表尾插入，O(1) //System.out.println(list.toString());//输出顺序表的描述字符串，O(n) inti=k;//计数起始位置 while(list.length()>1)//多于一个元素时循环，计数O(1) { i=(i+m-1)%list.length();//按循环方式对顺序表进行遍历,圆桌循环 System.out.print("出列"+list.remove(i).toString()+"，");//删除i位置对象，O(n) //System.out.println(list.toString()); } System.out.println("出列"+list.get(0).toString());//get(0)获得元素，O(1) } publicstaticvoidmain(Stringargs[]) { newJosephusA(15,2,9); } }第二部分：（4）、packageex2;publicclassNode<T>{ publicTdata; //数据域 publicNode<T>next; //地址域，后继结点 //构造结点 publicNode(Tdata,Node<T>next){ this.data=data; this.next=next; } //构造空结点 publicNode(){ this(null,null); } //描述字符串 publicStringtoString(){ returnthis.data.toString(); }}packageex2;publicclassSinglyList<T>{ publicNode<T>head; //构造空单链表 publicSinglyList() { head=newNode<T>(); } //构造单链表，由values数组数组提供元素 publicSinglyList(T[]values) { this(); Node<T>rear=this.head; for(inti=0;i<values.length;i++) { rear.next=newNode<T>(values[i],null); rear=rear.next; } } publicbooleanisEmpty()//判断线性表是否空 { returnthis.head.next==null; } publicTget(inti)//返回第i（i≥0）个元素{ Node<T>p=head.next; for(intj=0;p!=null&&j<i;j++) p=p.next; return(p!=null&&i>=0)?p.data:null; } publicvoidset(inti,Tx)//设置第i个元素值为x{ if(x==null) thrownewNullPointerException("x==null"); //抛出空对象异常 Node<T>p=this.head.next; //0 for(intj=0;p!=null&&j<i;j++) //遍历寻找第i个结点（p指向） p=p.next; if(i>0&&p!=null) p.data=x; } publicintsize()//返回线性表长度{ inti=0; for(Node<T>p=this.head.next;p!=null;p=p.next) i++; returni;} publicNode<T>insert(inti,Tx)//插入x作为第i个元素{ if(x==null) thrownewNullPointerException("x=null"); Node<T>front=this.head; //指定头结点 for(intj=0;front.next!=null&&j<i;j++) front=front.next; //以此循环找i-1 front.next=newNode<T>(x,front.next); returnfront.next; } publicNode<T>insert(Tx) {if(x==null)thrownewNullPointerException("x==null");//抛出空对象异常Node<T>front=this.head;//front指向头结点for(;front.next!=null;)//寻找第i-1个或最后一个结点（front指向）front=front.next;front.next=newNode<T>(x,front.next);//在front之后插入值为x结点，包括头插入、中间/尾插入returnfront.next;} publicTremove(inti)//删除第i个元素并返回被删除对象{ Node<T>p=this.head; //让p指向头结点 for(intj=0;j<i&&p.next!=null;j++) p=p.next; if(p.next!=null) { Told=p.next.data; p.next=p.next.next; returnold; } returnnull;} publicvoidremoveAll()//删除线性表所有元素{ this.head.next=null; //让头结点直接为空} publicNode<T>search(Tkey)//查找，返回首次出现的关键字为key元素{ for(Node<T>p=this.head;p.next!=null;p=p.next) if(key.equals(p.data)) returnp; returnnull; } publicStringtoString()//返回顺序表所有元素的描述字符串，形式为“（，）”{ Stringstr=this.getClass().getName()+"(";//返回类名for(Node<T>p=this.head.next;p!=null;p=p.next)//p遍历单链表{str+=p.data.toString();if(p.next!=null)str+=",";//不是最后一个结点时，加分隔符}returnstr+")"; } }（5）、packageex2;publicclassSortedSinglyList<TextendsComparable<?superT>>extendsSinglyList<T>{ //构造空排序单链表 publicSortedSinglyList() { super(); //默认调用父类构造方法SinglyList() } publicSortedSinglyList(SinglyList<T>list){super();//构造空单链表for(Node<T>p=list.head.next;p!=null;p=p.next)//直接插入排序，每趟插入1个元素this.insert(p.data);//排序单链表按值插入} //构造，将values数组中的所有对象按值插入 publicSortedSinglyList(Tvalues[]) { super(); for(inti=0;i<values.length;i++) this.insert(values[i]); } publicvoidset(inti,Tx)//设置第i个元素值为x { thrownewUnsupportedOperationException("set(inti,Tx)");//不支持父类方法，覆盖并抛出异常 } publicNode<T>insert(inti,Tx)//插入x作为第i个元素 { thrownewUnsupportedOperationException("set(inti,Tx)");//不支持父类方法，覆盖并抛出异常 } publicNode<T>insert(Tx)//在线性表最后插入x元素 { Node<T>p=this.head; for(;p.next!=null&&pareTo(x)>0;) p=p.next; p.next=newNode<T>(x,p.next); returnp.next; } publicNode<T>search(Tkey) //查找，返回首次出现的关键字为key元素 { for(Node<T>p=this.head;p.next!=null&&pareTo(p.data)<=0;p=p.next) if(pareTo(p.next.data)==0) returnp; returnnull; }}（6）、e、packageex2;publicclassDel1{ publicDel1(inti,intk){ Integer[]values={1,5,6,10,13}; SinglyList<Integer>list=newSinglyList<Integer>(values); System.out.println(list.toString()); for(intj=0;j<k;j++) list.remove(i); System.out.println("删除后："+list.toString()); } publicstaticvoidmain(String[]args){ newDel1(2,2); } }f、packageex2;publicclassDel2{ publicDel2(intmink,intmaxk) { Integer[]values={1,3,9,17,34}; SortedSinglyList<Integer>list=newSortedSinglyList<Integer>(values); System.out.println(list.toString()); Node<Integer>p=list.head; intj=0; while(p.next!=null&&p.next.data<=mink) { p=p.next; j++; } while(p.next!=null&&p.next.data<maxk) { list.remove(j); } System.out.println("list="+list.toString()); } publicstaticvoidmain(Stringargs[]) {newDel2(2,18);}}g、packageex2;publicclassMeger{publicMeger(){ Integer[]values1={1,2,5,7,9}; SortedSinglyList<Integer>val1=newSortedSinglyList<Integer>(values1); Integer[]values2={1,0,5,8,9}; SortedSinglyList<Integer>val2=newSortedSinglyList<Integer>(values2); SortedSinglyList<Integer>val=newSortedSinglyList<Integer>(); inti=0;intj=0; while(i<val1.size()&&j<val2.size()) { if(val1.get(i)<=val2.get(j)) {val.insert(val1.get(i)); if(val1.get(i)==val2.get(j)) j++; i++; } else {val.insert(val2.get(j)); j++; } } while(i<val1.size()) { val.insert(val2.get(i)); i++; } while(j<val2.size()) { val.insert(val2.get(j)); j++; } System.out.println(val1.toString()); System.out.println(val2.toString()); System.out.println(val.toString()); } publicstaticvoidmain(Stringargs[]) { newMeger(); }}(7)、packagePoly;publicinterfaceSubible<T>//可相加接口，T表示数据元素的数据类型{publicvoidsub(Tt);//+=加法，约定两元素相加规则publicbooleanremovable();//约定删除元素条件}packagePoly;//项类，一元多项式的一项，实现可比较接口和可相加接口publicclassTermXimplementsComparable<TermX>,Subible<TermX>{protectedintcoef,xexp;//系数，x指数（可为正、0）publicTermX(intcoef,intxexp)//构造一项{this.coef=coef;this.xexp=xexp;}publicTermX(TermXterm)//拷贝构造方法{this(term.coef,term.xexp);}//以“系数x^指数”的省略形式构造一元多项式的一项。//省略形式说明：当系数为1或-1且指数>0时，省略1，-1只写负号“-”，如x^2、-x^3；//当指数为0时，省略x^0，只写系数；当指数为1时，省略^1，只写x。publicTermX(Stringtermstr){if(termstr.charAt(0)=='+')//去掉+号termstr=termstr.substring(1);inti=termstr.indexOf('x');if(i==-1)//没有x，即指数为0{this.coef=Integer.parseInt(termstr);//获得系数this.xexp=0;}else//有x，x之前为系数，x^之后为指数{if(i==0)//以x开头，即系数为1this.coef=1;else{Stringsub=termstr.substring(0,i);//x之前子串表示系数if(sub.equals("-"))//系数只有-号，即系数为-1this.coef=-1;elsethis.coef=Integer.parseInt(sub);//获得系数}i=termstr.indexOf('^');if(i==-1)this.xexp=1;//没有^，即指数为1elsethis.xexp=Integer.parseInt(termstr.substring(i+1));//获得指数}}//返回一元多项式的一项对应的“系数x^指数”的省略形式字符串，省略形式说明同TermX(String)构造方法。publicStringtoString(){Stringstr=this.coef>0?"+":"-";//系数的符号位if(this.xexp==0||this.xexp>0&&this.coef!=1&&this.coef!=-1)str+=Math.abs(this.coef);//系数绝对值，省略系数1if(this.xexp>0)str+="x";//指数为0时，省略x^0，只写系数if(this.xexp>1)str+="^"+this.xexp;//指数为1时，省略^1，只写xreturnstr;}publicintcompareTo(TermXterm)//按x指数比较两项大小，实现Comparable<T>接口{if(this.xexp==term.xexp)//比较相等return0;//比较规则与equals(Object)不同returnthis.xexp<term.xexp?-1:1;//比较大小，仅比较指数}publicvoidsub(TermXterm)//若指数相同，则系数相减；实现Subible<T>接口{if(pareTo(term)==0)this.coef-=term.coef;elsethrownewIllegalArgumentException("两项的指数不同，不能相减。");}publicbooleanremovable()//若系数为0，则删除元素；实现Subible<T>接口{returnthis.coef==0;//不存储系数为0的项}//比较两项是否相等，比较系数和指数，比较规则与compareTo(term)==0不同publicbooleanequals(Objectobj){if(this==obj)returntrue;if(!(objinstanceofTermX))returnfalse;TermXterm=(TermX)obj;returnthis.coef==term.coef&&this.xexp==term.xexp;}}packagePoly;importex2.Node;importex2.SortedSinglyList;publicclassPolySinglyList<TextendsComparable<?superT>&Subible<T>>extendsSortedSinglyList<T>{publicPolySinglyList()//构造方法{super();//创建空单链表}publicPolySinglyList(Tterms[])//构造方法，由项数组指定多项式各项值{super(terms);}publicPolySinglyList(PolySinglyList<T>list)//拷贝构造方法{super();//单链表深拷贝，复制所有结点，没有复制对象}publicvoidsubAll(PolySinglyList<T>list)//多项式相减，this-=list功能，不改变list{Node<T>front=this.head,p=front.next;Node<T>q=list.head.next;while(p!=null&&q!=null)if(pareTo(q.data)==0)//两项大小相同{p.data.sub(q.data);//两项相加，add()方法由Subible接口约定if(p.data.removable())//相加后元素满足删除条件{//removable()方法由Subible接口约定front.next=p.next;//相加后元素不需要存储，删除p结点p=front.next;}else{front=p;//front是p的前驱结点p=p.next;}q=q.next;}elseif(pareTo(q.data)<0){front=p;p=p.next;}else{front.next=newNode<T>(q.data,p);//复制q结点并插入到front结点之后q=q.next;}while(q!=null)//将list单链表中剩余结点复制并插入到当前链表尾{front.next=newNode<T>(q.data,null);front=front.next;q=q.next;}}}packagePoly;importex2.Node;publicclassPolynomial{privatePolySinglyList<TermX>list;//多项式排序单链表，TermX表示一元多项式的一项publicPolynomial()//构造方法{this.list=newPolySinglyList<TermX>();//创建空单链表，执行排序单链表默认构造方法}publicPolynomial(TermXterms[])//构造方法，由项数组指定多项式各项值{this.list=newPolySinglyList<TermX>(terms);}publicPolynomial(Stringpolystr)//构造方法，参数指定多项式表达式字符串{this();if(polystr==null||polystr.length()==0)return;Node<TermX>rear=this.list.head;intstart=0,end=0;//序号start～end的子串为一项while(start<polystr.length()&&end<polystr.length()){inti=polystr.indexOf('+',e