Question

Improve the speed of public T get(int i) by having it work backward from the end of the array if you attempt to get a member which is closer to the end than the start. This improvement will be tested through timing tests on large lists. The method should still return null if i is not a valid index.

Code

import java.util.Iterator;

public class DLList<T> implements Iterable<T> {
   private static class Node<T> {
       public Node<T> prev, next;
       public T data;

       public Node(Node<T> prev, T data, Node<T> next) {
           this.prev = prev;
           this.next = next;
           this.data = data;

       }
   }

   private int numNodes;
   private Node<T> head, tail;

   private static class Conductor<T> implements Iterator<T> {
       public Node<T> car;

       public Conductor(DLList<T> list) {
           car = list.head;

       }

       public boolean hasNext() {
           return car != null;
       }

       public T next() {
           T data = car.data;
           car = car.next;
           return data;

       }

       public void remove() {
       }
   }

   public DLList() {
       head = tail = null;
   }

   public void add(T data) {
       if (tail == null) {
           head = new Node<T>(null, data, null);
           tail = head;
       } else {
           tail.next = new Node<T>(tail, data, null);
           tail = tail.next;
       }
       numNodes++;
   }

   public int size() {
       return numNodes;
   }

   public T get(int i) {
       if (i < 0)
           throw new IndexOutOfBoundsException();
       Node<T> current = head;
       for (int j = 0; current != null && j < i; j++) {
           current = current.next;
       }
       if (current == null)
           throw new IndexOutOfBoundsException();
       return current.data;
   }

   public T remove(int i) {
       if (i < 0)
           throw new IndexOutOfBoundsException();
       Node<T> current = head;
       for (int j = 0; current != null && j < i; j++) {
           current = current.next;
       }
       if (current == null)
           throw new IndexOutOfBoundsException();
       if (current.prev != null)
           current.prev.next = current.next;
       else
           head = head.next;
       if (current.next != null)
           current.next.prev = current.prev;
       else
           tail = tail.prev;
       numNodes--;
       return current.data;
   }

   public Iterator<T> iterator() {
       return new Conductor<T>(this);
   }

   private static class BackwardConductor<T> implements Iterator<T> {
       public Node<T> car;

       public BackwardConductor(DLList<T> list) {
           car = list.tail;
       }

       public boolean hasNext() {
           return car != null;
       }

       public T next() {
           T data = car.data;
           car = car.prev;
           return data;
       }

       public void remove() {
       }
   }

   public Iterator<T> descendingIterator() {
       return new BackwardConductor<T>(this);

   }

   public void reverse() {
       Node<T> temp = head, temp2;
       if (temp != null) {
           head = tail;
           tail = temp;
           temp = head;
           while (temp != tail) {
               temp2 = temp.next;
               temp.next = temp.prev;
               temp.prev = temp2;
               temp = temp.next;
           }
           temp2 = temp.next;
           temp.next = temp.prev;
           temp.prev = temp2;
       }
   }

   public boolean add(int i, T s) {
       if (i < 0 || i >= size()) {
           return false;
       }
       Node temp = head;
       for (int index = 0; index < i; index++) {
           temp = temp.next;
       }
       Node newNode = new Node<T>(temp.prev, s, temp);
       if (temp == head) {
           head.prev = newNode;
           head = newNode;
           numNodes++;
           return true;
       }
       temp.prev.next = newNode;
       temp.prev = newNode;
       numNodes++;
       return true;
   }

}

Answer 1

public T get(int i)
{
   int n = size();//getting size of the list
   if(0<=i && i<n)//if valid index
   {
       int s=i+1;
       int e = n-s;
       if(s<e)//then it is closer to starting
       {
           Node<T> temp = head;
           s=s-1;
           while(temp!=null && 0<s)
           {
               temp=temp.next;
               s--;  
           }
           return temp.data;//return element at index i
       }
       else//then it is closer to ending
       {
           Node<T> temp =tail;
           s=e;
           while(temp!=null && 0<s)
           {
               temp=temp.prev;
               s--;  
           }
           return temp.data;//return element at index i
          
       }
      
   }
  
   return null;//if not valid index
  
}