Java - Ayuda con este problema

package polinomios;

/**

 *

 * @author Andrés Mella Romero

 */

public class Main {

    public static void main(String[] args) {

         //Instanciamos un polinomio

        Polinomio polinomio = new Polinomio();

        //Instanciamos un término

        Termino termino = new Termino(3,2);

        //agregamso el término al polinomio

        polinomio.agregarTermino(termino);

         //Instanciamos un término

        termino = new Termino(-4,1);

        //agregamso el término al polinomio

        polinomio.agregarTermino(termino);

        //Lo imptimimos

        polinomio.imprimir();

        System.out.println();

        //Instanciamos un polinomio

        Polinomio polinomio2 = new Polinomio();

        //Instanciamos un término

        termino = new Termino(23.5,3);

         //agregamso el término al polinomio

        polinomio2.agregarTermino(termino);

        //Instanciamos un término

        termino = new Termino(-1,2);

         //agregamso el término al polinomio

        polinomio2.agregarTermino(termino);

        //Instanciamos un término

        termino = new Termino(-1,0);

         //agregamso el término al polinomio

        polinomio2.agregarTermino(termino);

        //Lo imptimimos

        polinomio2.imprimir();

        System.out.println();

        //Instanciamos a la clase que opera con polinomios

        Operaciones operaciones = new Operaciones();

        //Sumamos!

        Polinomio suma = operaciones.sumar(polinomio, polinomio2);

        //Imprimimos

        suma.imprimir();

        System.out.println();

        //Acabamos! :)

    }

}

package polinomios;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

/**

 *

 * @author Andrés Mella Romero

 */

//Clase que representa a un polinomio

public class Polinomio {

    //Inicio del Polinomio

    private Termino cabeza;

    //Constructor que inicializa la referencia al Polinomio

    public Polinomio() {

        cabeza = null;

    }

    //Método que obtiene el inicio del Polinomio

    public Termino getCabeza() {

        return cabeza;

    }

    //Método que verifica si en el polinomio existe un término con un exponente dado

    public boolean existeTerminoConExponente(Termino termino) {

        //Obtenemos la rerefencia al inicio del polinomio

        Termino iterador = cabeza;

        //Ciclamos por la lista

        while( null != iterador ) {

            //Compara los exponentes

            if(iterador.getExponente() == termino.getExponente()) {

                //Sí existe!

                return true;

            }

            //Siguiente elemento a iterar

            iterador = iterador.getSiguiente();

        }

        //No existe!

        return false;

    }

    //Similar al anterior, pero este regresa null ó el término

    public Termino obtenerTerminoPorExponente(Termino termino) {

        //Obtenemos la rerefencia al inicio del polinomio

        Termino iterador = this.cabeza;

        //Ciclamos por la lista

        while( null != iterador ) {

            //Compara los exponentes

            if(iterador.getExponente() == termino.getExponente()) {

                //Lo encontramos!

                return iterador;

            }

            //Siguiente elemento a iterar

            iterador = iterador.getSiguiente();

        }

        //No encontrado!

        return null;

    }

    //Obtienen el último término del Polinomio

    private Termino obtenerUltimoTermino() {

        //Obtenemos la rerefencia al inicio del polinomio

        Termino iterador = cabeza;

        //Ciclamos por la lista

        while( null != iterador && null != iterador.getSiguiente()) {

             //Siguiente elemento a iterar

            iterador = iterador.getSiguiente();

        }

        //Regresar el elemento

        return iterador;

    }

    //Agregar un termino al final del polinomio

    public void agregarTermino(Termino termino) {

        //Obtenemos el último término del polinomio

        Termino ultimoTermino = obtenerUltimoTermino();

        //Si no hay último término, agregamos como inicio

        if(null == ultimoTermino) {

            cabeza= termino;

        }else {

            //Establecer como siguiente elemento

            ultimoTermino.setSiguiente(termino);

        }

    }

    //Imprimir el polionomio

    public void imprimir() {

         //Obtenemos la rerefencia al inicio del polinomio

        Termino iterador = cabeza;

        //Una lista para ordenar los elmentos

        List<Termino> terminos = new ArrayList<Termino>();

        //Ciclamos por el polinomio

        while( null != iterador) {

           //Agregamos a la lista

           terminos.add(iterador);

           //Siguiente elemento a iterar

           iterador= iterador.getSiguiente();

        }

        //Ordenamos

        Collections.sort(terminos);

        //Imprimir!

        for(Termino termino : terminos){

            System.out.print(termino.toString()+" ");

        }

    }

}

package polinomios;

/**

 *

 * @author Andrés Mella Romero

 */

//Clase que representa un término

public class Termino implements Comparable<Termino> {

    //El coeficiente del término

    private double coeficiente;

    //El exponente del término

    private int exponente;

    //La referencia al siguiente término

    private Termino siguiente;

    //Constructor que recibe sólo el coeficiente

    public Termino(double coeficiente) {

        //su exponente en cero

        this(coeficiente, 0);

    }

    //Constructor que recibe el coeficiente y el exponente

    public Termino(double coeficiente, int exponente) {

        this.coeficiente = coeficiente;

        this.exponente = exponente;

        this.siguiente = null;

    }

    //Método para establecer el coeficiente

    public double getCoeficiente() {

        return coeficiente;

    }

    //Método para obtener el coeficiente

    public void setCoeficiente(double coeficiente) {

        this.coeficiente = coeficiente;

    }

    //Método para obtener el exponente

    public int getExponente() {

        return exponente;

    }

    //Método para establecer el exponente   

    public void setExponente(int exponente) {

        this.exponente = exponente;

    }

    //Método para obtener la referenccia al siguiente término

    public Termino getSiguiente() {

        return siguiente;

    }

    //Método para establecer la referenccia al siguiente término

    public void setSiguiente(Termino siguiente) {

        this.siguiente = siguiente;

    }

    //Imprimir un término

    @Override

    public String toString() {

        StringBuilder sb = new StringBuilder();

        if (0d != coeficiente) {

            if (coeficiente > 0) {

                sb.append("+");

            }

            sb.append(coeficiente);

            switch (exponente) {

                case 0:

                    break;

                case 1:

                    sb.append("x");

                    break;

                default:

                    sb.append("x^");

                    sb.append(exponente);

            }

        }

        return sb.toString();

    }

    //Para ordenar el polinomio según sus exponentes

    @Override

    public int compareTo(Termino o) {

        if (o.getExponente() == this.exponente) {

            return 0;

        } else if (o.getExponente() > this.exponente) {

            return 1;

        } else {

            return -1;

        }

    }

}

package polinomios;

/**

 *

 * @author Andrés Mella Romero

 */

//Clase que opera con Polinomios

public class Operaciones {

    //Método que suma dos polinomios

    public Polinomio sumar(Polinomio polinomio1, Polinomio polinomio2) {

        //Polinomio que contiene la suma       

        Polinomio suma = new Polinomio();

        //necesitamos que sean los mismos exponentes para sumar coeficientes!

        //Obtenemos la rerefencia al inicio del polinomio

        Termino iterador = polinomio1.getCabeza();

        //Ciclamos por el polinomio

        while( null != iterador ) {

           //Encontramos el término en el otro polinomio que tenga el mismo coeficiente

           Termino termino = polinomio2.obtenerTerminoPorExponente(iterador);

           //Sí lo encontramos, enconces, sumar ambos términos

           if( null != termino) {

            Termino sumando = new Termino(iterador.getCoeficiente()+termino.getCoeficiente(), termino.getExponente());

            suma.agregarTermino(sumando);

           }else {

               //Sí no lo encontramos, enconces, agregar a la suma

            suma.agregarTermino(new Termino(iterador.getCoeficiente(), iterador.getExponente()));

           }

           //Siguiente elemento a iterar

           iterador = iterador.getSiguiente();

        }

        //Ahora verifcar todos aquellos términos que no se encuantran en el polinomio 1

        //Obtenemos la rerefencia al inicio del polinomio

        iterador = polinomio2.getCabeza();

         //Ciclamos por el polinomio

        while( null != iterador ) {

            //Si no existe, simplemente agregar a la suma

            if(!polinomio1.existeTerminoConExponente(iterador)) {

                suma.agregarTermino(new Termino(iterador.getCoeficiente(), iterador.getExponente()));

            }

           //Siguiente elemento a iterar

            iterador = iterador.getSiguiente();

        }

        //Regresar la suma

        return suma;

    }

}