Question

in java

This class will require the following fields:

• Node<T> head: the first Node in the chain
• Node<T> tail: the last Node in the chain
• int size: Keeps a count of the number of Nodes in the chain

Your LinkedList class must also support the following public methods.

• LinkedList(): A default constructor sets both pointers to null and sets the size to 0.
• int size(): Returns the size of the LinkedList.
• void push_back(T): Creates a new Node and assigns it to the end of the list of Nodes while updating the size by 1.
• void push_front(T): Creates a new Node and assigns it to the front of the list of Nodes while updating the size by 1.
• T pop_back() throws ListEmptyException: Deletes the Node at the end of the list (or throws a ListEmptyException if this is not possible). Decreases size by 1. Returns the deleted element.
• T pop_front() throws ListEmptyException: Deletes the Node at the front of the list (or throws a ListEmptyException if this is not possible). Decreases size by 1. Returns the deleted element.
• T at(int) throws ListException: Returns the element stored at the specified index. If the index is out-of-bounds (either for being negative or greater than/equal the size of the list), throw a ListException with the message "Index out of bounds.” This method should operate at O(1) for accessing the first or last element in a list and at O(n) for any element other than the first or the last.
• T front() throws ListEmptyException: Returns the first element (throws a ListEmptyException if the list is empty)
• T back() throws ListEmptyException : Returns the last element (throws a ListEmptyException if the list is empty)
• void printAll(): prints all the nodes in the LinkedList

Answer 1

Java Code:

LinkedList.java

package queue;

class ListEmptyException extends Exception
{
public ListEmptyException(String s)
{
super(s);
}
}

class ListException extends Exception
{
public ListException(String s)
{
super(s);
}
}

class Node<T>
{
   T data;
   Node<T> next;
   Node(T data)
   {
       this.data = data;
       this.next = null;
   }
}

public class LinkedList<T> {
   private Node<T> head;
   private Node<T> tail;
   private int size;
  
  
   LinkedList() {
       head=tail=null;
       size = 0;
   }
  
   int size() {
       return size;
   }
  
   void push_back(T data) {
       Node<T> new_node = new Node<T>(data);
       if(head==null) {
           head = tail = new_node;
       }
      
       tail.next = new_node;
       tail = new_node;
       size++;
   }
  
   void push_front(T data) {
       Node<T> new_node = new Node<T>(data);
       if(head==null) {
           head = tail = new_node;
       }
      
       new_node.next = head;
       head = new_node;
       size++ ;
   }
  
   T pop_back() throws ListEmptyException {
       if(head == null)
           throw new ListEmptyException("Empty List.");
      
       Node<T> temp = head;
      
       if(head == tail) {
           head=tail=null;
           return temp.data;
       }
      
       while(temp.next != tail) {
           temp = temp.next;
       }
      
       T data = tail.data;
       tail = temp;
      
       return data;
   }
  
   T pop_front() throws ListEmptyException {
       if(head == null)
           throw new ListEmptyException("Empty List.");
      
       T data = head.data;
      
       if(head == tail) {
           head=tail=null;
           return data;
       }
      
      
      
       head = head.next;
      
       return data;
   }
  
   T at(int n) throws ListException {
       if(n < 1 || n>size)
           throw new ListException("Index out of bounds.");
      
       Node<T> temp = head;
      
       while(n > 1) {
           temp = temp.next;
           n--;
       }
      
       return temp.data;
   }
  
   T front() {
       return head.data;
   }
  
   T back() {
       return tail.data;
   }
  
   void printAll() {
       Node<T> temp = head;
      
       while(temp != tail.next) {
           System.out.print(temp.data + " ");
           temp = temp.next;
       }
       System.out.println();
   }
  
   public static void main(String[] args) throws ListException, ListEmptyException {
      
       LinkedList<Integer> L = new LinkedList<Integer>();
       L.push_front(1);
       L.push_front(0);
       L.push_back(2);
       L.push_back(3);
      
       System.out.print("List: "); L.printAll();
       System.out.println("Size: " + L.size());
       System.out.println("Front: " + L.front());
       System.out.println("Back: " + L.back());
       System.out.println("At 2: " + L.at(2));
       System.out.println("Pop from front: "+ L.pop_front());
       System.out.println("Pop from back: " + L.pop_back() + "\n");
       System.out.print("List: "); L.printAll();
      
   }
  
}

Pic for indentation:

Output :

List: 0 1 2 3
Size: 4
Front: 0
Back: 3
At 2: 1
Pop from front: 0
Pop from back: 3

List: 1 2

Hope you like it

Any Query? Comment Down!

I have written for you, Please upvote the answer as it encourage us to serve you Best !