Использование вложенного цикла for для добавления 2 связанных списков с помощью java.util.ListIterator;

Question

Я пытаюсь перебрать два связанных списка, используя цикл for и метод listIterator.

Я пытаюсь выполнить метод ниже, который добавляет два полинома, используя связанный список

public Polynomial add(Polynomial p)

POSTCONDITION: этот объект и p не изменены вернуть полином, который является суммой р и этот полином

Вот мой метод

public Polynomial add( Polynomial p )
{
    // use the copy constructor
    Polynomial answer = new Polynomial( this );
    // answer.termList.addAll(p.termList);
    // use addAll()
    //answer=this.termList.addAll(p.termList);
    //ListIterator<Term> itr = answer.termList.listIterator();
    //ListIterator<Term> itr = answer.termList.listIterator();
    //ListIterator<Term> itr2 = p.termList.listIterator();
    for ( ListIterator<Term> itr = answer.termList.listIterator(); itr.hasNext(); )
    {
        Term term = itr.next();

        for ( ListIterator<Term> itr2 = p.termList.listIterator(); itr2.hasNext(); )
        {
            Term term2 = itr2.next();
            if ( term.exponent == term2.exponent )
            {
                answer.itr.coefficient = answer.itr.coefficient + p.itr2.coefficient;
            }
        }
        /**while ( itr.hasNext() )
         {
         Term term = itr.next();
         }**/
        return answer;

    }
}

В этой строке for (ListIterator<Term> itr=answer.termList.listIterator();itr.hasNext();) и for(ListIterator<Term> itr2 = p.termList.listIterator(); itr2.hasNext();) есть ошибки.

Я получаю сообщение об ошибке, в котором говорится, что itr и itr2 не могут быть разрешены или не являются полем.

Вот часть кода, которая определяет полином, есть много методов, которые я не включил, так как они слишком длинные.

public class Polynomial implements Cloneable
{
    // this is a nested static class, it defines a type
    // all the instance varaibles can be access directly inside Polynomial
    // class even though they have

    // private modifier
    private static class Term
    {
        private int exponent;
        private double coefficient;

        public Term( int exp, double coeff )
        {
            coefficient = coeff;
            exponent = exp;
        }
    }

    // instance variables of Polynomial
    // first is the term of the Polynomial with the highest degree
    private LinkedList<Term> termList;

    /**
     * Postcondition:  Creates a polynomial which is 0.
     **/
    public Polynomial()
    {
        termList = new LinkedList<Term>();
        termList.add( new Term( 0, 0 ) );
    }

    /**
     * Postcondition:  Creates a polynomial which has a single term
     * a0*x^0
     *
     * @param a0 The value to be set as the coefficient of the
     *           constant (x^0) t                      erm.
     **/
    public Polynomial( double a0 )
    {
        termList = new LinkedList<Term>();
        termList.add( new Term( 0, a0 ) );
    }
}

Answer 1

Циклы не обязательно должны быть вложенными.

Это решение сохранит условия, отсортированные по убыванию показателя степени:

public class Polynomial {
    private List<Term> termList = new LinkedList<Term>();

    private static class Term {
        private int exponent;
        private double coefficient;

        private Term(int exponent, double coefficient) {
            this.exponent = exponent;
            this.coefficient = coefficient;
        }
    }

    public Polynomial() {
    }

    public Polynomial(int exponent, double coeff) {
        if (coeff != 0) {
            termList.add(new Term(exponent, coeff));
        }
    }

    public Polynomial add(Polynomial other) {
        Polynomial answer = new Polynomial();
        Iterator<Term> itr = termList.iterator();
        Iterator<Term> itr2 = other.termList.iterator();
        Term t = itr.hasNext() ? itr.next() : null;
        Term t2 = itr2.hasNext() ? itr2.next() : null;
        while (true) {
            if (t == null) {
                if (t2 == null) {
                    break;
                }
                answer.termList.add(new Term(t2.exponent, t2.coefficient));
                t2 = itr2.hasNext() ? itr2.next() : null;
            } else if (t2 == null) {
                answer.termList.add(new Term(t.exponent, t.coefficient));
                t = itr.hasNext() ? itr.next() : null;
            } else if (t2.exponent > t.exponent) {
                answer.termList.add(new Term(t2.exponent, t2.coefficient));
                t2 = itr2.hasNext() ? itr2.next() : null;
            } else if (t2.exponent < t.exponent) {
                answer.termList.add(new Term(t.exponent, t.coefficient));
                t = itr.hasNext() ? itr.next() : null;
            } else {
                answer.termList.add(
                        new Term(t.exponent, t.coefficient + t2.coefficient));
                t = itr.hasNext() ? itr.next() : null;
                t2 = itr2.hasNext() ? itr2.next() : null;
            }
        }
        return answer;
    }
}

Answer 2

Это неисправная линия

answer.itr.coefficient= answer.itr.coefficient + p.itr2.coefficient;

itr и itr2 являются объектами итераторов, а не членами Polynomial, я думаю, вы имели в виду

term.coefficient += term2.coefficient;

---

Обновление

Для полноты вот моя полная версия add метода

public Polynomial add(Polynomial p) {
    Polynomial answer = new Polynomial(this);
    for (ListIterator<Term> itr = answer.termList.listIterator(); itr.hasNext();) {
        Term term = itr.next();

        for (ListIterator<Term> itr2 = p.termList.listIterator(); itr2.hasNext();) {
            Term term2 = itr2.next();
            if (term.exponent == term2.exponent) {
                term.coefficient += term2.coefficient;
            } else {
                answer.termList.add(new Term(term2.exponent, term2.coefficient));
            }
        }
    }
    return answer;
}