Question

Add your own method (or use one or more of the existing methods) to insert the following set of numbers (1, 5, 19, 7, 23, 17, 2) in a linked list (use one function-call per number, and preserve the order of insertion). Once inserted print the linked list such that the output displays the numbers in reverse order. (2, 17, 23, 7, 19, 5, 1)

JAVA CODE BELOW

class aNode {

char data;
aNode next;

aNode(char mydata) { // Constructor
data = mydata;
next = null;
}
};
//-----------------------------------------------------

class linkedList {

aNode head; // Head of the linked list
int size;

linkedList() { // Constructor
head = null;
size = 0;
}
//-----------------------------------------------------

public void insert_at_beginning(char value) {
aNode newNode = new aNode(value); // create aNew node
newNode.next = head;
head = newNode;
size++;
}
//-----------------------------------------------------

public void insert_at_end(char value) {
aNode newNode = new aNode(value); // create aNew node
if (isEmpty()) {
newNode.next = head;
head = newNode;
size++;
} else {
//find the last node
aNode ptr;
ptr = head;
while (ptr.next != null) {
ptr = ptr.next;
}
ptr.next = newNode; //add the node to the end
size++;
}
}
//-----------------------------------------------------

public void insert_after(char value, char searchValue) {
if (isEmpty()) {
System.out.println("Linked List is empty, no way to insert " + value + " after " + searchValue);
} else {
//find the node with searchValue
aNode ptr;
boolean found = false;
ptr = head;
while (ptr != null && found == false) {
if (ptr.data == searchValue) {
found = true;
} else {
ptr = ptr.next;
}
}
if (ptr == null) {
System.out.println("Did not find " + searchValue + "Nothing Inserted");
} else {
aNode newNode = new aNode(value); // create aNew node
newNode.next = ptr.next;
ptr.next = newNode; //add the node after the searchValue
size++;
}
}
}
//-----------------------------------------------------
// Delete the first node with the value

public void delete(char deleteValue) {
if (isEmpty()) {
System.out.println("Linked List is empty, nothing to delete");
} else {
aNode deletePtr = head; // create a reference to head
if (head.data == deleteValue) {
head = head.next; // remove the head
deletePtr = null; // make the node available for garbage collection.
size--;
} else {
aNode prevPtr;
deletePtr = prevPtr = head;
boolean found = false;
//find the value to be deleted
while (deletePtr != null && found == false) {
if (deletePtr.data == deleteValue) { // Read about the difference between == and .equals()
found = true;
prevPtr.next = deletePtr.next;
deletePtr = null; // make deletePtr available to garbage collection
size--;
} else {
prevPtr = deletePtr;
deletePtr = deletePtr.next;
}
}
if (found == false) {
System.out.println("Not able to find/delete " + deleteValue + " in the Linked List");
}
}
}
}
//-----------------------------------------------------

public boolean isEmpty() {
if (head == null) {
return (true);
} else {
return (false);
}
}
//-----------------------------------------------------

public void print() {
aNode ptr;
ptr = head;
System.out.print("Head--> ");
while (ptr != null) {
System.out.print(ptr.data + " --> ");
ptr = ptr.next;
}
System.out.println("NULL");
}
//-----------------------------------------------------

public int getSize() {
return (size);
}
//-----------------------------------------------------

public void freeAll() {

aNode freePtr = head;
while (head != null) {
head = head.next;
// the next two lines are unnecessary, but are included for
// illustration of how memory is freed up
//
freePtr = null; // make the node available for garbage collector
freePtr = head; // now let the freePtr to the new head
}
head = null;
size = 0;

Answer 1

Please find the answer below.
Please do comments in case of any issue. Also, don't forget to rate the question. Thank You So Much.

LinkListTest.java

package c12;

class aNode {

   int data;
   aNode next;

   aNode(int mydata) { // Constructor
       data = mydata;
       next = null;
   }
};
//-----------------------------------------------------

class linkedList {

   aNode head; // Head of the linked list
   int size;

   linkedList() { // Constructor
       head = null;
       size = 0;
   }
   //-----------------------------------------------------

   public void insert_at_beginning(int value) {
       aNode newNode = new aNode(value); // create aNew node
       newNode.next = head;
       head = newNode;
       size++;
   }
   //-----------------------------------------------------

   public void insert_at_end(int value) {
       aNode newNode = new aNode(value); // create aNew node
       if (isEmpty()) {
           newNode.next = head;
           head = newNode;
           size++;
       } else {
           //find the last node
           aNode ptr;
           ptr = head;
           while (ptr.next != null) {
               ptr = ptr.next;
           }
           ptr.next = newNode; //add the node to the end
           size++;
       }
   }
   //-----------------------------------------------------

   public void insert_after(int value, int searchValue) {
       if (isEmpty()) {
           System.out.println("Linked List is empty, no way to insert " + value + " after " + searchValue);
       } else {
           //find the node with searchValue
           aNode ptr;
           boolean found = false;
           ptr = head;
           while (ptr != null && found == false) {
               if (ptr.data == searchValue) {
                   found = true;
               } else {
                   ptr = ptr.next;
               }
           }
           if (ptr == null) {
               System.out.println("Did not find " + searchValue + "Nothing Inserted");
           } else {
               aNode newNode = new aNode(value); // create aNew node
               newNode.next = ptr.next;
               ptr.next = newNode; //add the node after the searchValue
               size++;
           }
       }
   }
   //-----------------------------------------------------
   // Delete the first node with the value

   public void delete(int deleteValue) {
       if (isEmpty()) {
           System.out.println("Linked List is empty, nothing to delete");
       } else {
           aNode deletePtr = head; // create a reference to head
           if (head.data == deleteValue) {
               head = head.next; // remove the head
               deletePtr = null; // make the node available for garbage collection.
               size--;
           } else {
               aNode prevPtr;
               deletePtr = prevPtr = head;
               boolean found = false;
               //find the value to be deleted
               while (deletePtr != null && found == false) {
                   if (deletePtr.data == deleteValue) { // Read about the difference between == and .equals()
                       found = true;
                       prevPtr.next = deletePtr.next;
                       deletePtr = null; // make deletePtr available to garbage collection
                       size--;
                   } else {
                       prevPtr = deletePtr;
                       deletePtr = deletePtr.next;
                   }
               }
               if (found == false) {
                   System.out.println("Not able to find/delete " + deleteValue + " in the Linked List");
               }
           }
       }
   }
   //-----------------------------------------------------

   public boolean isEmpty() {
       if (head == null) {
           return (true);
       } else {
           return (false);
       }
   }
   //-----------------------------------------------------

   public void print() {
       aNode ptr;
       ptr = head;
       System.out.print("Head--> ");
       while (ptr != null) {
           System.out.print(ptr.data + " --> ");
           ptr = ptr.next;
       }
       System.out.println("NULL");
   }

   public void printReverse() {
       System.out.print("Tail --> ");
       aNode ptr;
       ptr = head;
       printReverseHelper(ptr);
       System.out.print("Head");
   }

   public void printReverseHelper(aNode ptr2) {
       if(ptr2==null) {
           return ;
       }else {
           printReverseHelper(ptr2.next);
           System.out.print(ptr2.data + " --> ");
       }
   }

   public int getSize() {
       return (size);
   }

   public void freeAll() {
       aNode freePtr = head;
       while (head != null) {
           head = head.next;
           // the next two lines are unnecessary, but are included for
           // illustration of how memory is freed up
           //
           freePtr = null; // make the node available for garbage collector
           freePtr = head; // now let the freePtr to the new head
       }
       head = null;
       size = 0;
   }
}

public class LinkListTest{
   public static void main(String[] args) {
       linkedList list = new linkedList();
       list.insert_at_end(1);
       list.insert_at_end(5);
       list.insert_at_end(19);
       list.insert_at_end(7);
       list.insert_at_end(23);
       list.insert_at_end(17);
       list.insert_at_end(2);
       System.out.println("Link list before : ");
       list.print();

       System.out.println("Link list in reverse order : ");
       list.printReverse();
   }
}