Question

In Java implement a class called Polynomials:

• This class should store the polynomial using a linked list with nodes. (do not use existing list classes in Java).

• This class should store only terms with non-zero coefficients.

• This class should store the polynomial terms in decreasing order of their powers.

• This class should have a constructor with no parameters that creates a polynomial with no terms, i.e. the polynomial 0.

• This class should have another constructor that takes a polynomial as a string, parses it and creates the polynomial accordingly. The string contains the polynomial, with each term separated by a space. The following should work when tested:

  • "4x^3 +3x^1 -5"

  • "-3x^4 -2x^5 -5 +11x^1"

• Do not write any other public methods other than those in the interface and the above two constructors.

Answer 1

Here is the code, well documented and commented:

filename: Polynomials.java

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

public class Polynomials{
   //we create a node which will be an element of the linked list
   //the node will store the coefficient and power of the non-zero term
   private class node{
       public int coeff;
       public int power;
       //we also need to store reference to next node as this is a linked list
       public node next;   //reference to next element in the list
       node(int Coeff, int Power){
           coeff = Coeff;
           power = Power;
           next = null;   //next element is null
       }
   }
   //we need to create reference to first element of the list
   private node first;
  
   public Polynomials(){
       /*
       * this is the empty polynomial;
       * i.e. polynomial with no terms;
       */
       first = null;
   }
  
   private int get_pow_coeff(String t, boolean f){
       /*
       * this function will extract the power and coefficient in the term t
       * boolean f tells whether we want to extract power(f=true) or coeff.(f=false)
       */

       int power;
       int coeff;
       //t must be of the form: (+/-/ )<coeff>x^<power>
       //we check if t contains '+' or '-'
       int i1 = t.indexOf("+");
       int i2 = t.indexOf("-");
       if(i1 == -1 && i2 == -1){
           //this means that t is: <coeff>x^<power>
           int i3 = t.indexOf("x");
           if(i3 == -1){   //this means that t is a constant term
               coeff = Integer.valueOf(t);
               power = 0;
           }
           else{
               //we now extract coeff. and power based on i3(index of "x")
               coeff = Integer.valueOf(t.substring(0, i3));
               power = Integer.valueOf(t.substring(i3+2));   //since i3+1 contains '^'
           }
       }
       else{
           //this means t is either: +<coeff>x^<power> or -<coeff>x^<power>
           //we ignore the case when '+' is present, however if '-' is present, we multiply the coeff by -1
           int i3 = t.indexOf("x");
           if(i3 == -1){   //this means that t is a constant term
               coeff = Integer.valueOf(t.substring(1));
               if(i2 != -1)
                   coeff = -1 * coeff;
               power = 0;
           }
           else{              
               //we now extract coeff. and power based on i3(index of "x")
               coeff = Integer.valueOf(t.substring(1, i3));
               if(i2 != -1)   //i.e. '-' is present
                   coeff = -1 * coeff;
               power = Integer.valueOf(t.substring(i3+2));   //since i3+1 contains '^'
           }
       }
      
       if(f)   //power extraction
           return power;
       else
           return coeff;          
   }

   public Polynomials(String poly){
       /*
       * this method parses the string, poly and accordingly updates the linked list
       * we assume that each term has a different power
       * we must store only the non-zero terms and in decreasing order of their powers
       * we use "+" as the connector connecting the terms in the list.
       * our strategy to parse the string is to first split it into tokens using space(" ") as delimiter
       * we then insert these tokens(terms) in the list using an insertion sort kind of algorithm, i.e.
       * we take each term and insert it into its correct(according to its power) position in the list.
       * our search is easy as we always maintain sorted(decreasing) order in the list
       */
       String[] tokens = poly.split(" ");
       //we now insert the tokens in the list using insertion sort
       for(String t: tokens){
           /*
           * we now iterate over the list searching for the correct position of term, t
           * since we don't have back references, it is important that we compare with the neighbour of the current element.
           * so that we can insert the new element in between if required.
           * we first check if last is null and if so, we just insert t as the list is empty.
           * however if list contains only one element, then its neighbour will be null and hence we need to handle this case
           * also when we reach the last element in the list while searching, this means that all elements in the list are bigger than t and hence its position is last
           * the last two cases above can be covered by a single condition in which we compare with the last element and accordingly insert.
           */
          
           int power = get_pow_coeff(t, true);
           int coeff = get_pow_coeff(t, false);  
           node temp = first;   //our iterator over the list reference
           if(temp == null){   //i.e. no element present in the list
               //now we just create a new node and insert t in the list
               node n = new node(coeff, power);
               first = n;
           }
           else{
               //now we iterate over the sorted list searching for the correct position of t by comparing its power with other powers
               boolean flag = false;
               while(temp.next != null){
                   int comp_power = temp.next.power;
                   if(power > comp_power){   //i.e. we need to insert t here
                       node n = new node(coeff, power);
                       n.next = temp.next;   //we point t's next element to temp's neighbour
                       temp.next = n;   //we point temp to n since it is now in b/w temp and its old neighbour
                       flag = true;   //we update this flag to assert that we have inserted t
                       break;   //we exit the loop since we have inserted t
                   }
                   else{   //we continue searching further down the list
                       temp = temp.next;
                   }
               }
               //now we insert t at the end if flag is false
               if(!flag){
                   int comp_power = temp.power;
                   if(power > comp_power){
                       node n = new node(coeff, power);
                       n.next = temp;
                       first = n;
                   }
                   else{
                       node n = new node(coeff, power);
                       n.next = null;
                       temp.next = n;
                   }
               }
           }
       }
   }
  
   /*
   * this function is not a part of the code
   * but it is useful to test correctness of the program
   * basically it just displays the elements of the list one by one in the order in which the list was filled
   * , i.e. starting from the first and going till the end
   * delete this function when submitting
   */
  
   public void display(){
       node temp = first;
       while(temp != null){
           System.out.println("Term power:= " + temp.power);
           System.out.println("Term coefficient:= " + temp.coeff);
           System.out.println();
           temp = temp.next;
       }
   }
}
************************************************************************************************

Testing code: filename: Driver.java

public class Driver{
   public static void main(String[] args){
       String s = "-3x^4 -2x^5 -5 +11x^1"; //change this according to the string you want to test for
       Polynomials p = new Polynomials(s); //second constructor of polynomials
       p.display();
   }
}

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

Compiling(On ubuntu machines):

> javac Polynomials.java

> javac Driver.java

> java Driver

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

Sample I/O:

String s = "-3x^4 -2x^5 -5 +11x^1" //as in Driver.java

Output:

Term power:= 5
Term coefficient:= -2

Term power:= 4
Term coefficient:= -3

Term power:= 1
Term coefficient:= 11

Term power:= 0
Term coefficient:= -5

----------------------------------------------------------------------------------------

String s = "4x^3 +3x^1 -5"

Output:

Term power:= 3
Term coefficient:= 4

Term power:= 1
Term coefficient:= 3

Term power:= 0
Term coefficient:= -5
-----------------------------------------------------------------------------------------