• API
• FAQ
• Tools
• Archive
SHARE
TWEET # Untitled a guest Feb 14th, 2020 87 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
1. /**
2.  * This class represnts a Polynom object.
3.  * @author (Eyal Oren)
4.  * @version (2020a, 30.1.2020)
5. **/
6. public class Polynom
7. {
8.     private PolyNode _head; //Instane variable to point to the Polynom first Node.
9.
10.     //Constructors:
11.     /**
12.      * Creates a new Polynom object.
13.      */
14.     public Polynom() //Deafult constructor, assigns the head of the polynom to be null.
15.     {
17.     }
18.
19.     /**
20.      * Creates a new Polynom object.
21.      * @param p, the head of the Polynom to be set.
22.      */
23.     public Polynom(PolyNode p) //Constructor to assign a given PolyNode for Polynom head to point at.
24.     {
26.     }
27.
28.     /**
29.      * Returns the head of the Polynom.
30.      * @return the head of the Polynom.
31.      *
32.      * Time Complexity O(1)
33.      * Space Complexity O(1)
34.      */
36.     {
38.     }
39.
40.     /**
41.      * Sets the head of the Polynom
42.      * @param p, the head of the Polynom to be set.
43.      *
44.      * Time Complexity O(1)
45.      * Space Complexity O(1)
46.      */
47.     public void setHead(PolyNode p) //Sets the head of the polynom to be the node given in the method.
48.     {
50.     }
51.
52.     /**
53.      * Adds a new PolyNode to the Polynom, in the correct place.
54.      * @param p, the PolyNode to insert.
55.      * @return the Polynom after instering the new PolyNode.
56.      *
57.      * Time Complexity O(n)
58.      * Space Complexity O(1)
59.      */
60.     public Polynom addNode (PolyNode p) //Adds a node to the polynom, keeping the polynom sorted by powers.
61.     {
62.         if (this._head == null) //If the polynom is empty of nodes, adding the given node to be the head of the polynom.
63.         {
65.             return this;
66.         }
67.
68.         if (p.getPower() > this._head.getPower()) //If the power of the given power is bigger than the head of the polynom, making it the new head.
69.         {
72.             return this;
73.         }
74.
75.         PolyNode h = _head; //Assigns a pointer to the head of the polynom.
76.
77.         while (h != null) //Going through all the nodes in the polynom and checking the following terms:
78.         {
79.             if (h.getNext() == null) //If the loop reached the end of the polynom, instering the given node as the last node in the polynom.
80.             {
81.                 if (h.getPower() == p.getPower())        //If the powers are the same, adding the coefficients.
82.                 {
83.                     h.setCoefficient(h.getCoefficient() + p.getCoefficient());
84.                 }
85.
86.                 else
87.                 {
88.                     h.setNext(p);  //Otherwise, setting the node recieved in the method to be the last node in the Polynom.
89.                 }
90.                 return this;
91.             }
92.
93.             else if (p.getPower() == h.getPower()) //If the polynom contains a node with the same power, adding the given node power to the node that is already in.
94.             {
95.                 h.setCoefficient(h.getCoefficient() + p.getCoefficient());
96.                 break; //Exiting the loop, considering the instertion has been completed.
97.             }
98.
99.             else if (p.getPower() < h.getPower() && p.getPower() > h.getNext().getPower()) //If the given node power is between two adjacent nodes, inserting it before it.
100.             {
101.                 PolyNode temp = h.getNext(); //Temp pointer to hold.
102.                 h.setNext(p); //Making the given node the next node of the first node.
103.                 p.setNext(temp); //Making the second node as the next of the given node.
104.                 break;  //Exiting the loop, considering the instertion has been completed.
105.             }
106.
107.             else
108.             {
109.                 h = h.getNext(); //If none of the above terms happen, checking the next node to insert at.
110.             }
111.         }
112.         return this;
113.     }
114.
115.     /**
116.      * Multiplies every PolyNode in the Polynom with a given scalar.
117.      * @param num, the scalar to multiply with.
118.      * @return the Polynom after multiplication.
119.      *
120.      * Time Complexity O(n)
121.      * Space Complexity O(1)
122.      */
123.     public Polynom multByScalar (int num) //Multiplies every PolyNode in the Polynom with a given scalar.
124.     {
125.         PolyNode p = _head; //Assigns a pointer to the head of the polynom.
126.         while (p != null)   //Going through all the nodes in the polynom. and mutiplying their coefficient with the given scalar.
127.         {
128.             p.setCoefficient(p.getCoefficient() * num);
129.             p = p.getNext();
130.         }
131.         return this;
132.     }
133.
134.     /**
135.      * Adds the given Polynom in the method, to this Polynom.
136.      * @param other, the Polynom to add to this Polynom.
137.      * @return this Polynom after adding the given Polynom to it.
138.      *
139.      * Time Complexity O(n)
140.      * Space Complexity O(n)
141.      */
142.     public Polynom addPol (Polynom other)
143.     {
144.         if (other._head == null) //If the polynom recived in the method is empty, returning this polynom.
145.         {
146.             return this;
147.         }
148.
149.         if (this._head == null) //If this polynom is empty, assigning this polynom to be the polynom recived and returning it.
150.         {
152.             return this;
153.         }
154.
157.
158.         if (h.getPower() > origin.getPower())   //If the power of the other head is bigger than the head of this head, inserting it as the new head.
159.         {
160.             PolyNode temp = new PolyNode(h);  //New node for the node to insert.
161.             h = h.getNext();
162.             temp.setNext(origin);             //Inserting the specific node in the polynom that has been reciived, between the two nodes.
165.         }
166.
167.         while (h != null)                               //Going through every node in the other polynom
168.         {
169.            while (origin != null)                       //Checking in this polynom, where to enter the specific node of the other polynom.
170.            {
171.                if (origin.getNext() == null)            //If we have reached to the end of this polynom:
172.                {
173.                    PolyNode temp = h;
174.                    h = h.getNext();
175.                    if (origin.getPower() == temp.getPower()) //If the powers are equal, adding the coefficients.
176.                    {
177.                        origin.setCoefficient(origin.getCoefficient() + temp.getCoefficient());
178.                        origin.setNext(temp.getNext());
179.                    }
180.                    else
181.                    {
182.                        origin.setNext(temp); //Otherwise, setting the specific node to be the last node in the Polynom at the moment.
183.                    }
184.                    break;
185.                }
186.
187.                else if (h.getPower() < origin.getPower() && h.getPower() > origin.getNext().getPower()) //If the power of the other node is just between two powers of this polynom, inserting it between them.
188.                {
189.                   PolyNode temp = new PolyNode(h); //New node for the node to insert.
190.                   temp.setNext(origin.getNext());
191.                   origin.setNext(temp);
192.                   h = h.getNext();
193.                }
194.
195.                else if (h.getPower() == origin.getPower())  //If the other node power is equal to this power, adding it's power to this power.
196.                {
197.                    origin.setCoefficient(origin.getCoefficient() + h.getCoefficient());
198.                    h = h.getNext();
199.                }
200.
201.
202.                else
203.                {
204.                    origin = origin.getNext(); //If none of the above reached, moving the origin pointer one node further.
205.                }
206.            }
207.         }
208.         return this;
209.     }
210.     /**
211.      * Multiplies the given Polynom with this Polynom.
212.      * @param other, the Polynom to multiply this Polynom with.
213.      * @return this Polynom after multiplying it with the given Polynom.
214.      */
215.     public Polynom multPol (Polynom other)
216.     {
217.         if (other == null || other._head == null) //If the given Polynom or it's head are null, returning this Polynom.
218.         {
219.             return this;
220.         }
221.
222.         if (this._head == null) //If this Polynom doesnt point on any vaild nodes, returning this Polynom.
223.         {
224.             return this;
225.         }
226.
227.         Polynom p = new Polynom();     //Creating new Polynom to hold the multiplied nodes.
228.
229.         //Assigning pointers to each Polynom head: ש
232.
233.         while (origin != null) //Going through all the nodes in this Polynom
234.         {
235.             while (r != null) //GOing through all the nodes in the given Polynom, for each Node in this polynom.
236.             {
237.                 PolyNode toAdd = new PolyNode(origin.getPower() + r.getPower(), origin.getCoefficient() * r.getCoefficient()); //Creating a new Node, which is the product of multiplying 2 nodes.
239.                 r = r.getNext();
240.             }
241.             if (r == null) //If the 2nd Polynom has reached it's end, pointing it back to the head. to multiply the next origin node with this Polynom nodes.
242.             {
244.             }
245.             origin = origin.getNext(); //After the iteration, moving the origin node to be the next one.
246.         }
248.         return this;
249.     }
250.
251.     /**
252.      * Returns the differential Polynom of this Polynom.
253.      * @return the differential Polynom of this Polynom.
254.      *
255.      *  Time Complexity O(n)
256.      *  Space Complexity O(1)
257.      */
258.     public Polynom differential() //Returns the differential Polynom of this Polynom.
259.     {
260.        PolyNode p = _head; //Assigns a pointer to the head of this Polynom.
261.
262.        while (p != null) //Going through each node in the Polyonm, to differante it.
263.        {
264.            if (p.getPower() == 0) //If the power of a node is 0, setting it's coefficient to be 0.
265.            {
266.                p.setCoefficient(0);
267.                p = p.getNext();
268.            }
269.
270.            else if (p.getPower() == 1) //If the power of a node is 1, setting it's power to be 0.
271.            {
272.                p.setPower(0);
273.                p = p.getNext();
274.            }
275.
276.            else //Otherise using the basic differential formula.
277.            {
278.                p.setCoefficient(p.getCoefficient() * p.getPower());
279.                p.setPower(p.getPower() - 1);
280.                p = p.getNext();
281.            }
282.        }
283.        return this;
284.     }
285.     /**
286.      * Returns a String that represents this Polynom.
287.      * @return a String that represnts this Polynom.
288.      *
289.      * Time Complexity O(n)
290.      * Space Complexity O(1)
291.      */
292.     public String toString()
293.     {
295.         {
296.             return ""; //If the Polynom is empty, returning an empty string.
297.         }
298.
299.         String str = "";
300.         boolean isFirst = true;
302.         while (p != null)             //Going through all the nodes in the Polyonm.
303.         {
304.             if (p.getCoefficient() != 0) //Adding a node only if it's coefficient is not zero.
305.             {
306.                 if (isFirst)  //If it's the first node, won't add a '+' sign.
307.                 {
308.                     str += p;
309.                     isFirst = false; //The first node has been added.
310.                 }
311.
312.                 else
313.                 {
314.                     if (p.getCoefficient() > 0)  //If it's not the first node.
315.                     {
316.                         str += "+" + p;
317.                     }
318.                     else
319.                     {
320.                         str += p;
321.                     }
322.                 }
323.             }
324.             p = p.getNext();
325.         }
326.         return str;
327.     }
328. //End of class Polynom.
329. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.
Top