Implementing Singly Linked List to Doubly Linked List (Java)

public void add(int index, E e){/** add code to set 'previous' & to improve performance [2 marks] */

if (index < 0 || index > size)

throw new IndexOutOfBoundsException(); //according to Java doc.

else if (index == 0) addFirst(e);

else if (index == size) addLast(e);

else {

Node newNode = new Node(e);

Node current = head; // ]

//*** REMOVING ***

public E removeFirst() { /** add code to set 'previous' [1 mark]*/

if (size == 0)

return null;

else {

Node temp = head; // element will be returned

head = head.next;

size--;

if (head == null) // if list becomes empty

tail = null;

return temp.element; // return the removed element

}

}

public E removeLast() { /** improve performance using 'previous' [1 mark]*/

if (size == 0)

return null;

else if (size == 1) {

Node temp = head;

head = tail = null;

size = 0;

return temp.element;

} else {

Node temp = tail; // to return it

Node current = head; // get ref. to second to last

for (int i = 0; i < size - 2; i++)

current = current.next;

tail = current;

tail.next = null; // remove last

size--;

return temp.element; // return last

}

}

public E remove(int index) { /** add code to set 'previous' [2 marks]*/

if (index < 0 || index >= size)

return null;

else if (index == 0)

return removeFirst();

else if (index == size - 1)

return removeLast();

else {

Node previous = head;

for (int i = 1; i < index; i++)

previous = previous.next;

Node current = previous.next;

previous.next = current.next;

size--;

return current.element;

}

}

public boolean remove(E e) {

if (indexOf(e) >= 0) { //if the element exists

remove(indexOf(e)); //call the other remove method

return true;

} else

return false;

}

public void clear() {

size = 0;

head = tail = null;

}

//*** GETTING ***

public E getFirst() {

if (size == 0)

return null;

else

return head.element;

}

public E getLast() {

if (size == 0)

return null;

else

return tail.element;

}

public E get(int index) { /** improve performance using 'previous' [1 mark]*/

if (index < 0 || index >= size)

return null;

else if (index == 0)

return getFirst();

else if (index == size - 1)

return getLast();

else {

Node current = head; // ]

for (int i = 0; i < index; i++) // ]- get a reference to node @ index

current = current.next; // ]

return current.element;

}

}

//*** SETTING ***

public E set(int index, E e) { /** improve performance using 'previous' [1 mark]*/

if (index < 0 || index > size - 1)

return null;

Node current = head;

for (int i = 0; i < index; i++)

current = current.next;

E temp = current.element;

current.element = e;

return temp;

}

//*** TOSTRING ***

public String toString() {

StringBuilder result = new StringBuilder("[");

Node current = head;

for (int i = 0; i < size; i++) {

result.append(current.element);

current = current.next;

if (current != null)

result.append(", "); // Separate two elements with a comma

else

result.append("]"); // Insert the closing ] in the string

}

return result.toString();

}

public String toReversedString(){/** write code to return a string representing the list from right to left [3 marks]*/

return null;

}

//*** CHECKING ***

public int size(){return size;}

public boolean contains(E e) {

Node current = head;

for (int i = 0; i < size; i++) {

if (current.element.equals(e))

return true;

current = current.next;

}

return false;

}

public int indexOf(E e) {

Node current = head;

for (int i = 0; i < size; i++) {

if (current.element.equals(e))

return i;

current = current.next;

}

return -1;

}

public int lastIndexOf(E e) { /** improve performance using 'previous' [3 marks]*/

int lastIndex = -1;

Node current = head;

for (int i = 0; i < size; i++) {

if (current.element.equals(e))

lastIndex = i;

current = current.next;

}

return lastIndex;

}

//*** HELPER METHODS ***

private void checkIndex(int idx) {

if (idx < 0 || idx >= size)

throw new IndexOutOfBoundsException("Index: " + idx + ", Size: "

+ size);

}

private Node getNodeAt(int index){ /** write code for this method to return a reference to a node at a given index [3 marks]*/

return null;

}

//*** INNER NODE CLASS ***

private static class Node { public Node previous;

/** add code to consider 'previous' [1 mark]*/

E element;

Node next;

public Node(E e) {

element = e;

}

}

}

for (int i = 1; i < index; i++) // ]- get a reference to index-1

current = current.next; // ]

newNode.next = current.next; // Link the new node to element @ index

current.next = newNode; // Link element @ index-1 to newNode

size++;

}

}