Question

Doubly Linked List Java Help

Details: First, read the DoublyLinkedList.java code and try to understand what each field stores and what each method is doing. Modify and complete the class as described below

•The field size was defined in the class but was never maintained. Set the current default value and modify it whenever it is needed in the existing methods and other methods you implement as it is needed. It should always include the number of Nodes inside the list.

•Overload the method add by a version of it that takes two parameters,index and value, and adds value at the location specified by index. If index is out-of-bound, throw the appropriate exception. (Hint: Note that you should be able to add a value at index of size.)

•Implement the method addAlternativethat takes a value and adds it after each already existing value in the list. If the list is empty, it should add the value as the first (and only)value in the list. Therefore, after calling it, if the list was empty it will have a size of 1, and if the list was not empty, then its new size is twice its previous size (every other element’s value is equal to the newly added value).

•Implement the method addAll that takes an index and an arbitrary number of values and adds those values at the given index. Note that you can get arbitrary an number of values by specifying “int... values” as the second argument in your method. Then, inside your method, you can treat values as an array of ints.

•Implement the method equals that takes another DoublyLinkedList and returns true if all element values in the current list and the given list are equal to each other, respectively.

•Implement the method toStringReverse that returns a String that is similar to the output of the toString method, but lists the values in the list in reverse order.

DoublyLinkedList.java code:

public class DoublyLinkedList {
  
    private Node front; // first element in the list
    private Node last; // last element in the list
    private int size; // number of elements in the list

    // post: constructs an empty list
    public DoublyLinkedList() {
        front = last = null;
    }

    // post: constructs a list with data in first element and "list" after that
    public DoublyLinkedList(int data, DoublyLinkedList list) {
       front = new Node(data);
       front.next = list.front;
        last = list.last;
    }
  
    // post: returns the integer at the given index in the list
    public int get(int index) {
       checkIndex(index);
        return nodeAt(index).data;
    }

    // post: returns the position of the first occurrence of the given value (-1 if not found)
    public int indexOf(int value) {
        int index = 0;
        Node current = front;
        while (current != null) {
            if (current.data == value) {
                return index;
            }
            index++;
            current = current.next;
        }
        return -1;
    }

    // post: appends the given value to the end of the list
    public void add(int value) {
       if (last != null) {
            last.next = new Node(value);
            last = last.next;
       }
       else {
           front = last = new Node(value);
       }
    }

    // post: removes value at the given index
    public void remove(int index) {
       checkIndex(index);
        if (index == 0) {
            front = front.next;
        } else {
            Node current = nodeAt(index - 1);
            current.next = current.next.next;
        }
    }

    // post: returns a reference to the node at the given index
    private Node nodeAt(int index) {
       checkIndex(index);
        Node current = front;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current;
    }
  
    // checks if index is out of bound and if it is throws IndexOutOfBoundsException
    private void checkIndex(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    }

    // post: creates a comma-separated, bracketed version of the list
    @Override
    public String toString() {
        if (front == null) {
            return "[]";
        } else {
            String result = "[" + front.data;
            Node current = front.next;
            while (current != null) {
                result += ", " + current.data;
                current = current.next;
            }
            result += "]";
            return result;
        }
    }
  
    // Node inner class containing the data, and next and previous references
    private static class Node {
        Node previous;
        int data;
        Node next;
      
        // constructor to create a Node with data and null previous and next references
        public Node(int data) {
            this.previous = this.next = null;
            this.data = data;
        }

        // constructor to add a new Node with data before another "next" node
        public Node(int data, Node next) {
            this.previous = null;
            this.data = data;
            this.next = next;
            if (next != null)
               next.previous = this;
        }

        // constructor to initialize a new Node with data between its "previous" and "next" node
        public Node(Node previous, int data, Node next) {
            this.previous = previous;
            this.data = data;
            this.next = next;
            if (previous != null)
               previous.next = this;
            if (next != null)
               next.previous = this;
        }
    }
}

Answer 1

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package printerjob;

public class DoublyLinkedList {

    private Node front; // first element in the list
    private Node last; // last element in the list
    private int size; // number of elements in the list

    // post: constructs an empty list
    public DoublyLinkedList() {
        front = last = null;
        size=10;//default size is 10
    }

    // post: constructs a list with data in first element and "list" after that
    public DoublyLinkedList(int data, DoublyLinkedList list) {
       front = new Node(data);
       front.next = list.front;
        last = list.last;
    }

    // post: returns the integer at the given index in the list
    public int get(int index) {
       checkIndex(index);
        return nodeAt(index).data;
    }

    // post: returns the position of the first occurrence of the given value (-1 if not found)
    public int indexOf(int value) {
        int index = 0;
        Node current = front;
        while (current != null) {
            if (current.data == value) {
                return index;
            }
            index++;
            current = current.next;
        }
        return -1;
    }

    // post: appends the given value to the end of the list
    public void add(int value) {
       if (last != null) {
            last.next = new Node(value);
            last = last.next;
       }
       else {
           front = last = new Node(value);
       }
    }
    //inserted node with index and value
    public void add(int index,int value){
        Node tempfront=front;
        int count=0;
        while(tempfront!=null){
            if(count==index){
                Node N=new Node(value);
                N.data=value;
                Node t=tempfront.next;
                tempfront.next=N;
                N.previous=tempfront;
                N.next=t;
                t.previous=N;
              
            }
            count++;
           tempfront=tempfront.next;
        }
      
      
    }
    //alter node after
    public void addAlternative(Node prev_Node, int new_data){
        if (prev_Node == null) {
        System.out.println("The given previous node cannot be NULL ");
        return;
    }

    Node new_node = new Node(new_data);
    new_node.next = prev_Node.next;
    prev_Node.next = new_node;
    new_node.previous = prev_Node;
    if (new_node.next != null)
        new_node.next.previous = new_node;
    }
    // add random element
    public void addAll(int index){
         Node tempfront=front;
        int count=0;
        while(tempfront!=null){
            if(count==index){
                Node N=new Node((int)Math.random());
             
                Node t=tempfront.next;
                tempfront.next=N;
                N.previous=tempfront;
                N.next=t;
                t.previous=N;
              
            }
            count++;
           tempfront=tempfront.next;
        }
    }
    // check equal of two linkedlist
    public void equals(Node front1,Node front2){
        int fl=0;
         while (front1 != null && front2 != null) {
            if(front1.data != front2.data) {
                fl=1;
                break;
            }
            front1 = front1.next;
            front2 = front2.next;
        }
         if(front1 != null || front2 != null){
             fl=1;
         }
         if(fl==0)
             System.out.println("Equals");
         else
             System.out.println("Not Equals");
    }
//print doubly list in reverse order
    public void Reverse(Node last){
     System.out.println("Traversal in reverse direction");
        while (last != null) {
            System.out.print(last.data + " ");
            last = last.previous;
        }
    }
    // post: removes value at the given index
    public void remove(int index) {
       checkIndex(index);
        if (index == 0) {
            front = front.next;
        } else {
            Node current = nodeAt(index - 1);
            current.next = current.next.next;
        }
    }

    // post: returns a reference to the node at the given index
    private Node nodeAt(int index) {
       checkIndex(index);
        Node current = front;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current;
    }

    // checks if index is out of bound and if it is throws IndexOutOfBoundsException
    private void checkIndex(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    }

    // post: creates a comma-separated, bracketed version of the list
    @Override
    public String toString() {
        if (front == null) {
            return "[]";
        } else {
            String result = "[" + front.data;
            Node current = front.next;
            while (current != null) {
                result += ", " + current.data;
                current = current.next;
            }
            result += "]";
            return result;
        }
    }

    // Node inner class containing the data, and next and previous references
    private static class Node {
        Node previous;
        int data;
        Node next;
    
        // constructor to create a Node with data and null previous and next references
        public Node(int data) {
            this.previous = this.next = null;
            this.data = data;
        }

        // constructor to add a new Node with data before another "next" node
        public Node(int data, Node next) {
            this.previous = null;
            this.data = data;
            this.next = next;
            if (next != null)
               next.previous = this;
        }

        // constructor to initialize a new Node with data between its "previous" and "next" node
        public Node(Node previous, int data, Node next) {
            this.previous = previous;
            this.data = data;
            this.next = next;
            if (previous != null)
               previous.next = this;
            if (next != null)
               next.previous = this;
        }
    }
}