Question

Help in JAVA please

Write a program that reads a list of students (first names only) from a file. It is possible for the names to be in unsorted order in the file but they have to be placed in sorted order within the linked list.

The program should use a doubly linked list.

Each node in the doubly linked list should have the student’s name, a pointer to the next student, and a pointer to the previous student. Here is a sample visual. The head points to the beginning of the list. The tail points to the end of the list.

When inserting consider all the following conditions:

if(!head){ //no other nodes

}else if (strcmp(data, head->name)<0){ //smaller than head

}else if (strcmp(data, tail->name)>0){ //larger than tail

}else{ //somewhere in the middle

}

When deleting a student consider all the following conditions:

student may be at the head, the tail or in the middle

Below, you will find a sample of what the file looks like. Notice the names are in unsorted order but the information placed in the linked list (above visual) is in sorted order. The name of the file should be “input.txt”.

In the text file, the word delete followed by a name, should delete the node with that specific student’s name from the doubly linked list. If the name is not found, then nothing is deleted.

(NOTE: The above visual represents only the first three lines from the text file below.)

Jim

jill   

John

delete jill

Bob

Jack   

delete jim

At the end of the program, traverse through the contents of the linked list in both ascending and descending order, using the doubly linked list, and write the contents into the file output.txt. For example, given the above list, here is the sample display:

Bob

Jack

John

=============

John

Jack   

Bob   

Answer 1

// DoublyLinkedList.java

public class DoublyLinkedList {

       // inner class DNode to represent a node in doubly linked list

       class DNode

       {

             private String name; // data

             private DNode prev; // pointer to previous node

             private DNode next; // pointer to next node

            

             // constructor that create a node with given name and pointers to prev and next is null

             public DNode(String name)

             {

                    this.name = name;

             }

            

       }

      

       private DNode head; // pointing to start of the list

       private DNode tail; // pointing to end of the list

      

       // constructor that creates an empty list

       public DoublyLinkedList()

       {

             head = null;

             tail = null;

       }

      

       // method to insert name in list in sorted order

       public void insert(String name)

       {

             DNode node = new DNode(name);

             if(head == null) // if empty list, insert as head node

             {

                    head = node;

                    tail = node;

             }else if(head.name.toLowerCase().compareTo(name.toLowerCase()) > 0) // if data in head > name then update head

             {

                    node.next = head;

                    head.prev = node;

                    head = node;

             }else if(name.toLowerCase().compareTo(tail.name.toLowerCase()) > 0) // if data in tail < name then update tail

             {

                    tail.next = node;

                    node.prev = tail;

                    tail = node;

             }else

             {

                    // insert in middle

                    DNode curr = head;

                    // loop to insert the node in the middle of the list

                    while(curr != null)

                    {

                           if(curr.name.toLowerCase().compareTo(name.toLowerCase()) > 0)

                           {

                                 curr.prev.next = node;

                                 node.prev = curr.prev;

                                 node.next = curr;

                                 curr.prev = node;

                                 return ;

                           }

                          

                           curr = curr.next;

                    }

             }

            

       }

      

       // method to remove a name from the list

       public void remove(String name)

       {

             // if list is empty, do nothing

             if(head != null)

             {

                    if(head.name.toLowerCase().compareTo(name.toLowerCase()) == 0) // if head is the node to be deleted update head

                    {

                           head = head.next;

                           if(head == null)

                                 tail = null;

                           else

                                 head.prev = null;

                          

                    }else

                    {

                           // delete the node in the middle or end

                           DNode curr = head;

                           while(curr != null)

                           {

                                  if(curr.name.toLowerCase().compareTo(name.toLowerCase()) == 0)

                                 {

                                        curr.prev.next = curr.next;

                                        if(curr.next != null)

                                        {

                                               curr.next.prev = curr.prev;

                                        }else

                                        {

                                               tail = curr.prev;

                                        }

                                       

                                        return;

                                 }

                                

                                 curr = curr.next;

                           }

                    }

             }

       }

      

       // method to display the list in ascending order

       public void display()

       {

             if(head == null)

                    System.out.println("List is empty");

             else

             {

                    DNode curr = head;

                   

                    while(curr != null)

                    {

                           System.out.println(curr.name);

                           curr = curr.next;

                    }

             }

       }

      

       // method to display the list in descending order

       public void displayReverse()

       {

             if(head == null)

                    System.out.println("List is empty");

             else

             {

                    DNode curr = tail;

                   

                    while(curr != null)

                    {

                           System.out.println(curr.name);

                           curr = curr.prev;

                    }

             }

       }

      

}

//end of DoublyLinkedList.java

// DoublyLinkedListDriver.java : Java program to test the DoublyLinkedList class

import java.io.File;

import java.io.FileNotFoundException;

import java.util.Scanner;

public class DoublyLinkedListDriver {

       public static void main(String[] args) throws FileNotFoundException {

             // test the class

             Scanner scan = new Scanner(new File("input.txt")); // open the file input.txt

            

             DoublyLinkedList list = new DoublyLinkedList();

            

             String name;

             while(scan.hasNext())

             {

                    name = scan.next();

                   

                    if(name.equalsIgnoreCase("delete"))

                    {

                           name = scan.next();

                           list.remove(name);

                    }else

                           list.insert(name);

             }

            

             scan.close();

             System.out.println("List in ascending order : ");

             list.display();

             System.out.println("List in descending order : ");

             list.displayReverse();

       }

}

//end of DoublyLinkedListDriver.java

Output:

Input file:

Output: