Question

Q1: You can find a file that defines the CircularlyLinked List class similar to what we discussed in the class. Download the file and work on it. Your task is to: 1. Complete the missing methods in the file as discussed in the class. Search for the comment/" MISSING / in the file to see the methods that need to be completed. 2. Add the following methods to the class a. public Node getMin 1. Task: find the node with the minimum element and return it without removing it from the list ii. Return the node with minimum element or null if empty b. public Node getMax 1. Task: find the node with the maximum element and return it without removing it from the list ii. Return the node with maximum element or null if empty c. public void swap(Node node1, Node node2) i. Task: swap the given nodes (don't swap just the elements of the node) if neither of them is null. Assume the nodes are already in list. ii. Param two nodes: node1 and node2 are the nodes to be swapped. d. public int sumEven i. Task: calculate the sum of the even elements only assuming the type of the element is integer ii. Return the value of the sum of even elements e. public void display 1. Task: print the elements of the list starting from the first element and separated by -> 3. Provide a test class. Inside main, create a circularly link list object of integer elements. Then, ask the user to enter positive integer numbers and -1 to stop and add these numbers to the circular list in the order they were entered. Then, display the list. Swap the minimum node with the maximum node and then display the list. Finally, print the sum of the even numbers in the list. Check the sample output. Please enter positive integers, -1 to stop. 10 43 9725168-1 The list is: 10->4->3->9->7->2->5->1->6-> The list after swapping the minimum with the maximum is: 1->4->3->9->7->2->5-> 10->6->8 The sum of the even numbers is 30

Answer 1

Code:-

import java.util.*;

public class CircularyLinkedList {
//---------------------nested Node class--------------------
/**
   *Singly linked node, which stores a reference to its element
   and
   *to the subsequent node in the list.
*/
   private static class Node {
       /** The element stored at this node*/
       private int element; // an element stored at this node
       /** A reference to the subsequent node in the list*/
       private Node next; // a reference to the subsequent node in the list
           /**
       * Creates a node with the given element and next node
       *
       *@param e the element to be stored
       *@param n reference to a node that should follow the new node
       */
       public Node(int e, Node n) {
           element = e;  
           next = n;
       }
   }
   Node tail=null;
   int size=0;
   //Accessor methods
   /**
   *Returns the element stored at the node.
   * @return the element stored at the node
   */
   // public int getElement() { return this.element;}
   /**
   *Returns the node that follows this one (or null if no such node).
   *@return the following node
   */
   public int first(){ // returns (but does not remove) the first element
       if (size==0) return -1;
       return tail.next.element;   // the head is *after* the tail
   }

   /**
   Returns (but does not remove) the last element of the list
   *@return element at the back of the list (or 1 it empty)
   */
   public int last(){ //returns (but does not remove) the last element
       if(size==0) return -1;
       return tail.element;
   }
   // update methods

   /**
   *Rotate the first element to the back of the list.
   */
   public void rotate() { // rotate the first element to the back of the list
       if (tail != null)    // if empty, do nothing
           tail = tail.next;   // the old head becomes the new tail
   }

   /**
   *Adds an element to the front of the list.
   *@param e the new element to add
   */
   public void addFirst(int e) {    //adds element e to the front of the list
       if (size == 0) {
           tail = new Node(e, null);
           tail.next = tail;    // link to itself circularly
       } else {
           Node newest = new Node(e, tail.next);
           tail.next = newest;
       }
       size++;
   }

   /**
   * Adds an element to the end of the list.
   * @param e the new element to add
   */
   public void addLast(int e) { // adds elements to the end of the list
       if(size==0){           // insert new element at front of list
           tail = new Node(e, null);
           tail.next =tail;
       }
       else{
           Node newest = new Node(e,tail.next);
           tail.next = newest;
           tail = newest;       // now new element becomes the tail
       }     
       size++;   
   }

   /**
   * Removes and returns the first element of the list.
   *@return the removed element (or -1 if empty)
   */
   public int removeFirst() { // removes and Returns the first element
       if (size==0) return -1;            // nothing to remove
       Node head = tail.next;
       if (head == tail) tail = null;        // must be the only node left
       else                    // rernoves "head" from the list
           tail.next = head.next;
       size--;
       return head.element;
   }

   /**
   *Removes and returns the Last element of the list.
   * @return the removed element (or -1 if empty)
   */  
   public int removeLast(){
       if(size==0) return -1;
       Node head = tail.next;
       Node ptr=null;
       if(head == tail) tail = null;
       else{
           while(head.next != tail){
               head = head.next;
           }
           head.next = tail.next;
           ptr = tail;
           tail = head;
       }
       size--;
       return ptr.element;
   }

   /**
   *Returns the node with the minimum element in the list.
   * @return the node with minimum element in the list (or null If empty)
   */
   public Node getMin(){
       if(size==0) return null;
       Node ptr = tail;
       Node min = ptr;
       while(ptr.next != tail){
           if(min.element > ptr.element)
               min = ptr;
           ptr = ptr.next;
       }
       if(min.element > ptr.element)
           min = ptr;
       return min;
   }

   /**
   * Returns the node with the maximum element in the list.
   *@return the node with maximum element in the list (or null if empty)
   */
   public Node getMax(){
       if(size==0) return null;
       Node ptr = tail;
       Node max = ptr;
       while(ptr.next != tail){
           if(max.element < ptr.element)
               max = ptr;
           ptr = ptr.next;
       }
       if(max.element < ptr.element)
           max=ptr;
       return max;
   }

   /**
   *Swap two nodes as a whole (without swapping the elements alone), the nodes should not be null
   *@param node1 the first node to be swapped
   * @param node2 the second node to be swapped
   */
   public void swap(Node node1, Node node2){
       int temp = node1.element;
       node1.element = node2.element;
       node2.element = temp;
   }
   /**
   *Returns the sum of the even elements in the list
   */
   public int sumEven(){
       if(size==0) return -1;
       int sum=0;
       Node ptr = tail;
       while(ptr.next != tail){
           if(ptr.element % 2 ==0)
               sum += ptr.element;
           ptr = ptr.next;
       }
       if(ptr.element % 2 ==0)
               sum += ptr.element;
       return sum;
   }
   public void display(){
       Node ptr = tail.next;
       while(ptr != tail){
           System.out.print(ptr.element+"->");
           ptr = ptr.next;
       }
       System.out.print(ptr.element+"\n");
   }
   public static void main(String[] args) {
       System.out.println("Please enter positive integers, -1 to stop.");
       int a=0;
       Scanner sc = new Scanner(System.in);
       CircularyLinkedList c = new CircularyLinkedList();
       while(a != -1){
           a = sc.nextInt();
           if(a != -1)
               c.addLast(a);
       }
       System.out.println("The List is:");
       c.display();
       System.out.println("The list after swapping the minimum with the maximum is:");
       Node max = c.getMax();
       Node min = c.getMin();
       c.swap(max,min);
       c.display();
       System.out.println("The sum of the even numbers is "+c.sumEven());
   }
}

Output:-

​​​​​​

Note:-

Here in this program i not using getElement() and getNext().

I use node.element and node.next.