Question

Implement an array-based Linked List in Java. Use double as the item. You need to create a driver includes several items and inserts them in order in a list.

1. Identify the necessary methods in a List Linked implementation. Look at previous Data Structures (stack or queue) and be sure to include all necessary methods.
2. DO NOT USE your language's Library List. You will receive zero points.
3. Write a LinkedList class
4. Write a driver (tester) call LinkListedDriver to show you have implemented all the necessary methods

Answer 1

The above problem can be solved in the following steps-

STEP 1- First we will define a class LinkedList. Inside this class we will define a node class named LLNode. This LLNode class will have two variables value and next. Value stores int value and next stores next LLNode.

STEP 2- Then we write the function codes for inserting node at last, inserting node at beginning, deleting a node with a particular value and printing values of linked list.

The actions taken in functions have been mentioned in comments for proper understanding.

STEP 3- Then we created another class which is the tester class- LinkedListDriver class. In the main method of this class, we create an instance of LinkedList class.

And then we start calling the insertLast() and insertBeginning() functions with values. Then display the linked list. And then delete a particular node and again display the linked list.

JAVA CODE-

LinkedList.java

//defined class LinkedList
public class LinkedList {
   //defined a class LLNode that stores value and next LLNode
   class LLNode{
   //store value
   double value;
   //stores next LLNode
   LLNode next;
   //constructor
   LLNode(double val){
   value = val;
   next = null;
   }
   }
   //declare a LLNode Object to store the head of LinkedList
   public LLNode headNode = null;
  
   //function to insert value at the beginning of LinkedList
   public void insertBeginning(double value){
   //create an object of LLNode
       LLNode newNode = new LLNode(value);
       //make this newNode as headNode
       newNode.next = headNode;
       headNode = newNode;
   }
   //function to insert value at the last of LinkedList
   public void insertLast(double value){
   //create an object of LLNode
   LLNode newNode = new LLNode(value);
//check if headNode is null
   if(headNode == null){
   //then this newNode becomes headNode
   headNode = newNode;
   }
   //otherwise
   else{
   //store headNode in current
       LLNode current = headNode;
       //move current to last of LinkedList
       while(current.next != null){
           current = current.next;
       }
       //assign newNode at the last
   current.next = newNode;
   }
   }
   //function to delete a node with value=valToDel
   public void deleteNode(double valToDel){
   //store headNode in curr
       LLNode curr = headNode,prev = null;
       //check if curr is null and value in curr is valToDel at the same time
       if(curr!=null && curr.value == valToDel){
       //then make the headNode as next to headNode
           headNode = headNode.next;
           //end function by returning
           return;
       }
       //now run a loop till we find the node with value=valToDel
       while(curr!=null && curr.value != valToDel){
       //store curr in previous node
           prev = curr;
           //and move curr to next node
           curr = curr.next;
       }
       //check if curr is null, meaning valToDel is not found in any node
       //then end function call by returning
       if(curr == null) return;
       //assing next of prev as next of curr
       prev.next = curr.next;
      
   }
   //function to display the content of LinkedList
   public void display(){
   //store the headNode as current
   LLNode current = headNode;
   //check if current is null, means LinkedList is Empty
   if(current == null){
   System.out.println("Empty list");
   }
   //iterat over all elements in LinkedList
   while(current!=null){
   //print the value in node
   System.out.print(current.value+ " ");
   //move to next node
   current = current.next;
   }
   //change line after printing every node
   System.out.println();
   }
  
}

Image of Code-

LinkedListDriver.java

//LinkedListDriver class to test the LinkedList class
//it has all function calls to LinkedList functions
public class LinkedListDriver {
   //driver method
   public static void main(String args[]){
       //create an instance of LinkedList class
       LinkedList lld = new LinkedList();
       //insert 2.5 at last
       lld.insertLast(2.5);
       //insert 3.8 at last
   lld.insertLast(3.8);
   //insert 7.21 at beginning of linked list
   lld.insertBeginning(7.21);
   //insert 1.65 at beginning of linked list
   lld.insertBeginning(1.65);
   //print the contents of Linked list
   System.out.println("Linked list after insertions : ");
   lld.display();
  
   //delete the node with values=7.21
   lld.deleteNode(7.21);
   //print the contents of linked list after deletion
   System.out.println("Linked list after deletion : ");
   lld.display();
  
   }
}

Image of Code-

OUTPUT-

If this answer helps, please give an up vote and feel free to comment for any query.