Write a method expand that could be added to the LinkedlntList class from lecture and section. The method accepts an integer fas a parameter and replaces every value/with f copies of the value (i/f). Suppose a LinkedlntList variable list stores the following values: [21, 8, 15, 0, -_3, 32] The call list.expand(3); would change the list to store the following elements: \\7. 7. 7. 2. 2. 2. 5. 5. 5. 0. 0. 0. -1. -1. -1. 10. 10. 101 If an element of the original list is not evenly divisible by f, as with 8 and 32 above, the resulting list should truncate any fractional component (as is done naturally by integer division). If the parameter value passed is 1, the list is unchanged. If it is 0 or negative, the list should become empty. For full credit, your solution must run in O(N) time where N is the length of the list. You may not call any methods of the linked list class to solve this problem, and you may not use any auxiliary data structure to solve this problem (such as an array, ArrayList, Queue, String, etc). Assume that you are using the LinkedlntList and ListNode class as defined in lecture and section: public class LinkedlntList { private ListNode front; methods public class ListNode { public int data;//data stored in this node public ListNode next;//a link to the next node in the list public ListNode() {...} public ListNode(int data) {...} public ListNode(int data, ListNode next) {...} Solution //Function: public void expand(int f) { ListNode ptr = start; ListNode prev; while(ptr!=null) { prev=ptr.getLink(); //get the existing data int i=ptr.getData(); // find quotient int v=i/f; //replace existing data with quotient ptr.setData(v); //f-1 times expanding the same node for(int i=0;i<f-1;i++) { //create new node with quotient value ListNode nptr = new ListNode(v, null); // attach to list ptr.setLink(nptr); ptr=nptr.getLink(); } ptr.setLink(prev); // moving to the next node in the original list ptr=prev; } } .

1. Write a method expand that could be added to the LinkedlntList class from lecture and section.
The method accepts an integer fas a parameter and replaces every value/with f copies of the
value (i/f). Suppose a LinkedlntList variable list stores the following values: [21, 8, 15, 0, -_3,
32] The call list.expand(3); would change the list to store the following elements: 7. 7. 7. 2. 2.
2. 5. 5. 5. 0. 0. 0. -1. -1. -1. 10. 10. 101 If an element of the original list is not evenly divisible by
f, as with 8 and 32 above, the resulting list should truncate any fractional component (as is done
naturally by integer division). If the parameter value passed is 1, the list is unchanged. If it is 0 or
negative, the list should become empty. For full credit, your solution must run in O(N) time
where N is the length of the list. You may not call any methods of the linked list class to solve
this problem, and you may not use any auxiliary data structure to solve this problem (such as an
array, ArrayList, Queue, String, etc). Assume that you are using the LinkedlntList and ListNode
class as defined in lecture and section: public class LinkedlntList { private ListNode front;
methods public class ListNode { public int data;//data stored in this node public ListNode
next;//a link to the next node in the list public ListNode() {...} public ListNode(int data) {...}
public ListNode(int data, ListNode next) {...}
Solution
//Function:
public void expand(int f)
{
ListNode ptr = start;
ListNode prev;
while(ptr!=null)
{
prev=ptr.getLink();
//get the existing data
int i=ptr.getData();
// find quotient
int v=i/f;
//replace existing data with quotient
ptr.setData(v);

2. //f-1 times expanding the same node
for(int i=0;i<f-1;i++)
{
//create new node with quotient value
ListNode nptr = new ListNode(v, null);
// attach to list
ptr.setLink(nptr);
ptr=nptr.getLink();
}
ptr.setLink(prev);
// moving to the next node in the original list
ptr=prev;
}
}