链表实现的多项式加法与乘法

public class Node {  
      
    private int a;  
    private int i;  
    Node next;  

   public Node(int a,int i,Node next){
        this.a=a;  
         this.i=i;  
         this.next=next;
  }  
      
    public Node(int a,int i){  
          
         this.a=a;  
         this.i=i;  
         this.next=null;  
    }  
    public Node(){  
          
        this(0,0);  
    }  
    public int getA() {  
        return a;  
    }  
    public int getI() {  
        return i;  
    }  
    public void setA(int a) {  
        this.a = a;  
    }  
    public void setI(int i) {  
        this.i = i;  
    }  
      
}  

多项式类（单链表实现）

public class PolyList {  
      
    Node head;  
    Node current;  
      
    public PolyList(){  
          
        head=new Node();  
        current=head;  
        head.next=null;  
    }  
      
    //是否为空   
    public boolean isEmpty(){  
          
        return head.next==null;  
    }  
    //这里只考虑按顺序插入元素   
    public void insert(Node node){  
          
        current.next=node;  
        current=node;  
    }  
   
      
    //加法运算   
    public static PolyList add(PolyList p1,PolyList p2){  
          
         PolyList result=new PolyList();  
         //分别指向p1 p2的第一个元素   
         p1.current=p1.head.next;  
         p2.current=p2.head.next;  
         while(p1.current!=null && p2.current!=null){  
               
              if(p1.current.getI()==p2.current.getI()){  
                    
                   
              result.insert(new Node(p1.current.getA()+p2.current.getA(),p1.current.getI()));  
                  p1.current=p1.current.next;  
                  p2.current=p2.current.next;  
              }  
              else if(p1.current.getI()<p2.current.getI()){  
                    
                  result.insert(p1.current);  
                  p1.current=p1.current.next;  
                    
              }else{  
                  result.insert(p2.current);  
                  p2.current=p2.current.next;  
              }  
         }  
         while(p1.current!=null){  
               
              result.insert(p1.current);  
              p1.current=p1.current.next;  
         }  
         while(p2.current!=null){  
               
              result.insert(p2.current);  
              p2.current=p2.current.next;  
         }  
         return result;  
           
    }  
    //乘法运算   
    public static PolyList multiply(PolyList p1,PolyList p2){  
          
         PolyList result=new PolyList();  
         //分别指向p1 p2的第一个元素   
         p1.current=p1.head.next;  
         p2.current=p2.head.next;  
         while(p1.current!=null){  
               
               while(p2.current!=null)  
               {  
                   int a=p1.current.getA()*p2.current.getA();  
                   int i=p1.current.getI()+p2.current.getI();  
                   result.insert(new Node(a,i));  
                   p2.current=p2.current.next;  
               }  
               p1.current=p1.current.next;  
               p2.current=p2.head.next;  
         }  
         合并同类项   
         result.current=result.head.next;  
         Node tempPrevious=result.current;  
         Node temp=result.current.next;  
         while(result.current.next!=null){  
               
             while(temp!=null)  
             {  
                 if(temp.getI()!=result.current.getI())  
                 {  
                     temp=temp.next;  
                     tempPrevious=tempPrevious.next;  
                 }else{  
                     result.current.setA(result.current.getA()+temp.getA());  
                     tempPrevious.next=temp.next; //temp节点已经合并，将其从result中删除。
                     temp=temp.next;  
                 }  
                       
             }  
             result.current=result.current.next;  
             tempPrevious=result.current;  
             temp=result.current.next;  
         }         
         return result;  
    }  

  
}  

多项式加法： result 用来保存结果。p1.current 和 p2.current 分别指向 p1 和 p2 的第一个元素，比较它们的幂，如果相等，将它们的系数相加，幂不变，这一新项插入到 result 中，p1.current 和 p2.current 都往后移一位；如果 p1.current 所指向的项的幂小于 p2.current ，则把 p1.current 所指向的这一项插入到 result 中，p1.current 后移一位；同样地，如果 p2.current 所指向的项的幂小于 p1.current ，执行类似的操作。重复这一过程，直到这两个指针都指向 null 。（在单链表中，最后一个结点的 next 指向null）这里还有一个细节，就是这两个指针中一般都会有一个先指向 null ，那么这时候很简单，把剩下的那个指针往后遍历，它及其后面所指向的项都插入 result 即可。

乘法运算的算法比加法还要简单，同样result 用来保存结果， p1.current先固定， p2.current 遍历，p1.current 的指向乘以 p2.current 所指的每一项，这一次结束后 p1.current 后移一位，重复上述过程，直到 p1.current 指向 null 。不过结果最后有一个合并同类项的问题。
下载源码：