資料結構作業：

多項式合併，連結串列實現。

感覺這個寫的還是挺合格的，哈哈。

import java.util.*;
public class PolySinglyListTest {

	public static void main(String[] args) {
		PolySinglyList Ax=new PolySinglyList("1+x-x^2-x^3+x^5+x^10");
		System.out.println("表示式AX="+Ax);
		PolySinglyList Bx=new PolySinglyList("-x+2x^2+x^3+x^12");
		System.out.println("表示式BX="+Bx);
		PolySinglyList Cx=PolySinglyList.add(Ax, Bx);
		System.out.println("表示式CX=AX+BX="+Cx);
	}
}
class PolySinglyList{
	TermNode head;
	public PolySinglyList() {
		this.head=new TermNode(-1,-1);						//頭節點用特殊值-1標記。不和後面衝突
	}
															//這個函式比下面的更復雜，更嘔心。。。
	PolySinglyList(String polystr){
        this();
        if (polystr==null || polystr.length()==0)
            return;
        TermNode rear = this.head;
        int start=0, end=0;                                //stat表示這一項起始位置，end是結束位置
        while (start<polystr.length() && end<polystr.length()){
            int i=polystr.indexOf('+',end+1);              //返回字元+在字串中從end+1開始的序號
            if (i==-1)                                     //未找到指定字元
                i=polystr.length();
            int j=polystr.indexOf('-',end+1);
            if (j==-1)
                j=polystr.length();
            end=i<j? i: j;                                 //end為下一個+或-號的序號
 //           System.out.println("start="+start+", end="+end+", "+polystr.substring(start,end));
            rear.next = new TermNode(polystr.substring(start,end));
            //System.out.println(rear.next);
                       //尾插入，以序號start～end的子串作為一項，建立結點，建立元素物件
            rear = rear.next; 
            start=end;
        }
	}												
    public void add(TermNode term) {								//新增一個節點的函式
    	if(term.removeable()) return;							//如果這一項係數是0，不用新增。
    	TermNode rear=head;
    	while(rear.next!=null) {
    		if(rear.next.compareTo(term)==0) {					//如果相等直接新增
    			rear.next.add(term);
    			if(rear.next.removeable()) {					//如果新增後可以移除，直接移除
    				rear.next=rear.next.next;
    			}
    			return;
    		}else if(rear.next.compareTo(term)>0) {				//如果下面那個大於這個，那這個插入到中間
    			term.next=rear.next;
    			rear.next=term;
    			return;
    		}
    		rear=rear.next;
    	}
    	rear.next=term;											//如果遍歷到最後一點，末端插入
    }
	public void add(PolySinglyList list) {
		TermNode rear1=head;
		TermNode rear2=list.head;
		while(rear1.next!=null&&rear2.next!=null) {				//遍歷兩個連結串列
			if(rear1.next.compareTo(rear2.next)==0) {			//如果某節點相等，add運算
				rear1.next.add(rear2.next);
				if(rear1.next.removeable()) {
					rear1.next=rear1.next.next;
				}
				else
					rear1=rear1.next;
				rear2=rear2.next;
			}else if(rear1.next.compareTo(rear2.next)>0) {		//如果不相等，插入。
				TermNode term=new TermNode(rear2.next);			
				term.next=rear1.next;
				rear1.next=term;
				rear1=term;
				rear2=rear2.next;
			}else {
				rear1=rear1.next;
			}
		}
		if(rear2.next!=null) {
			rear1.next=rear2.next;
		}
    }
	//靜態相加函式，返回值是兩個表示式相加
	public static PolySinglyList add(PolySinglyList Ax,PolySinglyList Bx) {
		PolySinglyList Cx=Ax.Clone();
		Cx.add(Bx);
		return Cx;
	}
	//克隆。
	public PolySinglyList Clone() {
		PolySinglyList Cx=new PolySinglyList();
		TermNode rear1=Cx.head;
		TermNode rear2=this.head;
		while(rear2.next!=null) {
			rear1.next=new TermNode(rear2.next);
			rear1=rear1.next;
			rear2=rear2.next;
		}
		return Cx;
	}
	public String toString() {
		String str="";
		TermNode rear=head;
		while(rear.next!=null) {
			if(rear!=head&&rear.next.getCoef()>0)
				str+='+';
			str+=rear.next.toString();
			rear=rear.next;
		}
		return str;
	}
}
class TermNode{
	private int coef,xexp;								//係數，x指數
	public TermNode next;								//下一個節點
	public TermNode() {}
	public TermNode(int c,int x) {						//兩個引數的建構函式
		this.coef=c;
		this.xexp=x;
	}
	public TermNode(TermNode term) {
		this(term.coef,term.xexp);
	}
														   //這個函式有些複雜，考慮的情況比較多。比較嘔心QWQ
    public TermNode(String termstr){
        if (termstr.charAt(0)=='+')                        //去掉+號
            termstr=termstr.substring(1);
        int i = termstr.indexOf('x');
        if (i==-1) {                                       //沒有x，即指數為0        
            this.coef = Integer.parseInt(termstr);         //獲得係數
            this.xexp = 0;
        }else {                                            //有x，x之前為係數，x^之後為指數
            if (i==0) {                                    //以x開頭，即係數為1
                this.coef = 1;
            } else{
                String sub=termstr.substring(0,i);         //x之前子串表示係數
                if (sub.equals("-"))                       //係數只有-號，即係數為-1
                    this.coef=-1;
                else
                    this.coef = Integer.parseInt(sub);     //獲得係數
            }
            i = termstr.indexOf('^');
            if (i==-1)
                 this.xexp=1;                              //沒有^，說明指數是1
            else
                 this.xexp = Integer.parseInt(termstr.substring(i+1));//獲得指數
        }
    }
	public String toString() {		
		String str="";
		if((this.coef!=1&&this.coef!=-1)||this.xexp==0)			//如果是1或者-1的話，可以去掉
			str+=this.coef+"";
		if(this.coef==-1)
			str+='-';
		if(this.xexp!=0) {
			str+="x^"+this.xexp;
		}
		return str;
	}
	public int compareTo(TermNode term) {						//比較兩個點指數的大小
		return this.xexp-term.xexp;
	}
	public void add(TermNode term) {							//add函式，指數相同，就相加
		if(this.xexp==term.xexp)
			this.coef+=term.coef;
	}
	public boolean removeable() {								//判斷是否可以移除此節點（係數為0可以移除）
		return this.coef==0;
	}
	public int getCoef() {										//因為對指數和係數進行了封裝，所以要有get函式
		return this.coef;
	}
	public int getXexp() {
		return this.xexp;
	}
}