Question

                         Polynomial Using LinkedList class of Java Language

Description: Implement a polynomial class using a LinkedList defined in Java


(1) Define a polynomial that has the following methods for Polynomial

a. public Polynomial() 

        POSTCONDITION: Creates a polynomial represents 0

b. public Polynomial(double a0)

        POSTCONDITION: Creates a polynomial has a single x^0 term with coefficient a0

c. public Polynomial(Polynomial p)

        POSTCONDITION: Creates a polynomial is the copy of p


d. public void add_to_coef(double amount, int exponent)

     POSTCONDITION: Adds the given amount to the coefficient of the specified exponent.
     Note: the exponent is allowed to be greater than the degree of the polynomial   
      example: if p = x + 1, after p.add_to_coef(1, 2), p = x^2  + x + 1
          

e.  public void assign_coef(double coefficient, int exponent)
     POSTCONDITION: Sets the coefficient for the specified exponent.
     Note: the exponent is allowed to be greater than the degree of the polynomial   

f. public double coefficient(int exponent) 
     POSTCONDITION: Returns coefficient at specified exponent of this polynomial. 
     Note: the exponent is allowed to be greater than the degree of the polynomial   
     e.g. if p = x + 1; p.coeffcient(3) should return 0

g. public double eval(double x)
     POSTCONDITION: The return value is the value of this polynomial with the given value for the variable x.
     Do not use power method from Math, which is very low efficient 

h. public boolean equals (Object p)

        POSTCONDITION: return true if p is a polynomial and it has same terms as this polynomial

i. public string toString()

        POSTCONDITION: return the polynomial as a string like “2x^2 + 3x + 4”
        
        Important only non-zero terms 

j. public Polynomial add(Polynomial p)
     POSTCONDITION:
                this object and p are not changed   
                return a polynomial that is the sum of   p and this polynomial 


k. public Polynomial multiply(Polynomial p)
     POSTCONDITION: 
     this object and p should not be changed
     returns a new polynomial obtained by multiplying this term and p. For example, if this polynomial is
     2x^2 + 3x + 4 and p is 5x^2 - 1x + 7, then at the end of this function, it will return the polynomial 10x^4 + 13x^3 + 31x^2 + 17x + 28.


 

Answer 1

public class Polynomial {

        class PolyNode {
                double coeff;
                int degree;
                PolyNode next;

                public PolyNode(double coeff, int degree) {
                        this.coeff = coeff;
                        this.degree = degree;
                }
        }

        private PolyNode head; // points to the first Node of a Polynomial

        public Polynomial() // DO NOT MODIFY THIS CONSTRUCTOR
        {
                head = null;
        }

        public Polynomial(Polynomial p) // a "copy" constructor
        {
                // get the node of list
                PolyNode n = p.head;
                while (n != null) {
                        // when we add, it automatically makes the element head, if there is
                        // only element
                        add_to_coef(n.coeff, n.degree);

                        // go to next element
                        n = n.next;
                }
        }

        public Polynomial(double a0) {
                head = null;
                add_to_coef(a0, 0);
        }
        
        public void assign_coef(double coefficient, int exponent) {
                PolyNode tmp = head;
                
                while(tmp != null) {
                        if(tmp.degree == exponent) {
                                tmp.coeff = coefficient;
                                return;
                        }
                        tmp = tmp.next;
                }
                
                // if node is not found, create new node
                add_to_coef(coefficient, exponent);
        }
        
        public double coefficient(int exponent) {
                PolyNode tmp = head;
                
                while(tmp != null) {
                        if(tmp.degree == exponent) {
                                return tmp.coeff;
                        }
                        tmp = tmp.next;
                }
                
                return 0;
        }
        
        public double eval(double x) {
                double val = 0;
                PolyNode tmp = head;
                
                while(tmp != null) {
                        val += Math.pow(x, tmp.degree) * tmp.coeff;
                        tmp = tmp.next;
                }
                
                return val;
        }

        /**
         * Creates a new Term and Node containing it and inserts it in its proper place
         * in this Polynomial (i.e. in ascending order by exponent)
         */
        public void add_to_coef(double amount, int exponent) {
                if (amount == 0)
                        return;

                // create node
                PolyNode n = new PolyNode(amount, exponent);

                // if it is the first element
                if (head == null) {
                        head = n;
                } else {
                        // if it has same exponent as head
                        if (head.degree == exponent) {
                                head.coeff = (head.coeff + amount);
                                return;
                        } else if (head.degree < exponent) {
                                // it need to be inserted before head
                                n.next = head;
                                head = n;
                                return;
                        }

                        // loop like p will be the previous node, and we will be comparing
                        // p.next inside
                        // keep previous node information is required as we need to add this
                        // node in between
                        PolyNode p = head;
                        while (p.next != null) {

                                if (exponent == p.degree) {
                                        // if same exponent term is there
                                        p.coeff = (p.coeff + amount);
                                        return;
                                } else if (exponent > p.next.degree) {
                                        // loop till we get some lower exponent position
                                        n.next = p.next;
                                        p.next = n;
                                        return;
                                }

                                // move to next
                                p = p.next;
                        }

                        if (p.degree == exponent) {
                                p.coeff = (p.coeff + amount);
                                return;
                        }

                        // add to the last
                        p.next = n;
                }
        }

        String getTerm(double coefficient, int exponent) {
                String s = "+";
                if (coefficient < 0) {
                        s = "";
                }
                if (coefficient == 1 && exponent == 1)
                        return s + "x";
                else if (exponent == 0)
                        return s + String.valueOf(coefficient);
                else if (coefficient == 1)
                        return s + "x^" + String.valueOf(exponent);
                else if (exponent == 1)
                        return s + String.valueOf(coefficient) + "x";
                else
                        return s + String.valueOf(coefficient) + "x^" + String.valueOf(exponent);
        }

        /**
         * Returns a polynomial as a String in this form: x + 3x^2 + 7x^3 + x^5
         */
        public String toString() {
                String s = "";
                PolyNode node = head;
                String seperator = "";
                // for each term, do add
                while (node != null) {
                        s += seperator + getTerm(node.coeff, node.degree);
                        node = node.next;
                        seperator = " ";
                }
                return "(" + s + ")";
        }

        /**
         * Multiply this Polynomial by another Polynomial
         */
        public Polynomial multiply(Polynomial p) {
                Polynomial result = new Polynomial();
                PolyNode p1 = head;
                // traverse for each term of p1
                while (p1 != null) {

                        PolyNode p2 = p.head;

                        // traverse for each term of p2
                        while (p2 != null) {
                                // add the new term to result polynomial
                                result.add_to_coef(p1.coeff * p2.coeff, p1.degree + p2.degree);

                                // advance p2
                                p2 = p2.next;
                        }

                        // advance p1
                        p1 = p1.next;
                }
                return result;
        }

        /**
         * Add this Polynomial and another Polynomial
         */
        public Polynomial add(Polynomial p) {

                // create a copy of original polynomial
                // we will add new node to directly this.
                Polynomial result = new Polynomial(this);

                PolyNode p1 = p.head;
                // our add Term method, add the coefficients, if exponent is same,
                // else it will create a new term
                while (p1 != null) {
                        result.add_to_coef(p1.coeff, p1.degree);
                        p1 = p1.next;
                }

                return result;
        }

        /**
         * subtract this Polynomial and another Polynomial
         */
        public Polynomial minus(Polynomial p) {

                // create a copy of original polynomial
                // we will add new node to directly this.
                Polynomial result = new Polynomial(this);

                PolyNode p1 = p.head;
                // our add Term method, add the coefficients, if exponent is same,
                // else it will create a new term
                // we are changing the sign of coefficient here, so that it can be added
                while (p1 != null) {
                        result.add_to_coef(-1 * p1.coeff, p1.degree);
                        p1 = p1.next;
                }

                return result;
        }

        public boolean equals(Polynomial p) {
                PolyNode p1 = this.head;
                PolyNode p2 = p.head;

                while (p1 != null || p2 != null) {
                        if ((p1.coeff != p2.coeff) || (p1.degree != p2.degree)) {
                                return false;
                        }
                        p2 = p2.next;
                        p1 = p1.next;
                }
                return true;
        }
}

**************************************************

Thanks for your question. We try our best to help you with detailed answers, But in any case, if you need any modification or have a query/issue with respect to above answer, Please ask that in the comment section. We will surely try to address your query ASAP and resolve the issue.

Please consider providing a thumbs up to this question if it helps you. by Doing that, You will help other students, who are facing similar issue.