Krdytkyu

Disclaimer: This was an exam question we took and we have already solved it. But my friends and I are not sure if this is the right approach. Here is the question(verbatim) and our solution.

For this problem, you must implement the following methods
String deleteFirst() boolean isEmpty(). This deleteFirst () method removes the node in position 1 of the list and returns the string
contained in that node. The isEmpty() method returns true if there are no items in the list, false otherwise.

If deleteFirst() is called on a list that contains 0 or 1 element, an IllegalStateException must be thrown. A toString method has been provided so you can test your code.
Example. Suppose your list has these values:
["Barca","Inter","Utd"]
After executing deleteFirst, the list should contain these elements (in this order):
["Barca", "Utd"]

Requirements for Problem:

1. Your code must run correctly for lists containing any number of elements, including an empty list.


2. No data may be placed in the header node.


3. 
   IllegalStateException must be thrown when deleteFirst is called on your list when it has only 0 or 1 element.


4. You must use Java's IllegalStateException class (you must not create your own exception class for this.


5. You may not introduce any new instance variables or instance methods, and you may not modify the other methods in DoublyLinkedDeleteFirst.


6. The Node class contained in DoublyLinkedDeleteFirst must not be modified (in particular, no constructor other than the default constructor should be used to construct instances of Node ).


7. During execution, each Node in your DoublyLinkedDeleteFirst must have correct values for the next and previous Nodes.


8. 
   

   There should be no compiler or runtime errors. In particular, no NullPointerException should be thrown during execution.

   
   
   

   public class DoublyLinkedDeleteFirst {

   
   
   

   Node header;
   
   
   
   public DoublyLinkedDeleteFirst() {
   
       header = new Node();
   
   }
   
   
   
   //removes the node at position 1 and returns
   
   //the string contained in that node
   
   public String deleteFirst() {
   
       //implement
   
       Node temp = header;
   
   
   
       try {
   
           temp = temp.next.next;
   
           Node deleted = temp;
   
   
   
           temp.previous.next = temp.next;
   
           temp.next.previous = deleted.previous;
   
           return deleted.value;
   
       }catch (NullPointerException e) {
   
           throw new IllegalStateException();
   
       }
   
   
   
   }
   
   
   
   public boolean isEmpty() {
   
       if(header == null)
   
           return true;
   
       return false;
   
   }
   
   
   
   // adds to the end of the list
   
   public void addLast(String item) {
   
       Node next = header;
   
       while (next.next != null) {
   
           next = next.next;
   
       }
   
       Node n = new Node();
   
       n.value = item;
   
       next.next = n;
   
       n.previous = next;
   
   
   
   }
   
   
   
   @Override
   
   public String toString() {
   
   
   
       StringBuilder sb = new StringBuilder();
   
       toString(sb, header);
   
       return sb.toString();
   
   
   
   }
   
   
   
   private void toString(StringBuilder sb, Node n) {
   
       if (n == null)
   
           return;
   
       if (n.value != null)
   
           sb.append(" " + n.value);
   
       toString(sb, n.next);
   
   }
   
   
   
   class Node {
   
       String value;
   
       Node next;
   
       Node previous;
   
   
   
       public String toString() {
   
           return value == null ? "null" : value;
   
       }
   
   }
   
   
   
   public static void main(String args) {
   
       DoublyLinkedDeleteFirst list = new DoublyLinkedDeleteFirst();
   
       list.addLast("Inter Millan");
   
       list.addLast("Barcelona");
   
      //list.addLast("Manchester United");
   
       String deleted = list.deleteFirst();
   
       System.out.println("This item was deleted: " + deleted);
   
       System.out.println(list);
   
    }
   
   }