Double Linked List
  1. public class Node
  2. {
  3. private int data;
  4. private Node prev;
  5. private Node next;
  6.  
  7. public Node()
  8. {
  9. data = 0;
  10. prev = null;
  11. next = null;
  12. }
  13.  
  14. public int getData()
  15. {
  16. return data;
  17. }
  18.  
  19. public Node getPrev()
  20. {
  21. return prev;
  22. }
  23.  
  24. public Node getNext()
  25. {
  26. return next;
  27. }
  28.  
  29. public void setData(int d)
  30. {
  31. data = d;
  32. }
  33.  
  34. public void setPrev(Node p)
  35. {
  36. prev = p;
  37. }
  38.  
  39. public void setNext(Node l)
  40. {
  41. next = l;
  42. }
  43. }
  1. public class List
  2. {
  3. private Node head;
  4. private Node tail;
  5. private int count;
  6.  
  7. public List()
  8. {
  9. head = null;
  10. tail = null;
  11. count = 0;
  12. }
  13.  
  14. public boolean isEmpty()
  15. {
  16. return (count == 0);
  17. }
  18.  
  19. public int getSize()
  20. {
  21. return count;
  22. }
  23.  
  24. public int getElement(int index)
  25. {
  26. if(index < 0 || index > count) return -1;
  27. Node walker;
  28. if(index < (count/2))
  29. {
  30. walker = head;
  31. for(int i = 0; i < index; i++)
  32. walker = walker.getNext();
  33. }
  34. else
  35. {
  36. walker = tail;
  37. for(int i = 0; i < (count-index-1); i++)
  38. walker = walker.getPrev();
  39. }
  40.  
  41. return walker.getData();
  42. }
  43.  
  44. public String toString()
  45. {
  46. String str = "[";
  47. Node walker = head;
  48. while(walker != null)
  49. {
  50. str = str + " " + walker.getData();
  51. walker = walker.getNext();
  52. }
  53.  
  54. return str+" ]";
  55. }
  56.  
  57. public boolean search(int element)
  58. {
  59. Node walker = head;
  60. while(walker != null && walker.getData() != element)
  61. walker = walker.getNext();
  62. if(walker == null)
  63. return false;
  64. else
  65. return true;
  66. }
  67.  
  68. public boolean insert(int element, int index)
  69. {
  70. if(index < 0 || index > count)
  71. return false;
  72.  
  73. Node newNode = new Node();
  74. newNode.setData(element);
  75.  
  76. //insert the first node
  77. if(count == 0)
  78. {
  79. head = newNode;
  80. tail = newNode;
  81. count++;
  82. return true;
  83. }
  84.  
  85. //insert in the front
  86. if(index == 0)
  87. {
  88. newNode.setNext(head);
  89. head.setPrev(newNode);
  90. head = newNode;
  91. count++;
  92. return true;
  93. }
  94.  
  95. //insert in the end
  96. if(index == count)
  97. {
  98. newNode.setPrev(tail);
  99. tail.setNext(newNode);
  100. tail = newNode;
  101. count++;
  102. return true;
  103. }
  104.  
  105. //insert in the middle
  106. Node walker;
  107. if(index < (count/2))
  108. {
  109. walker = head;
  110. for(int i = 0; i < index-1; i++)
  111. walker = walker.getNext();
  112. }
  113. else
  114. {
  115. walker = tail;
  116. for(int i = 0; i < (count-index); i++)
  117. walker = walker.getPrev();
  118. }
  119. System.out.println("Walk to the destnition ...");
  120. newNode.setNext(walker.getNext());
  121. newNode.setPrev(walker);
  122. walker.getNext().setPrev(newNode);
  123. walker.setNext(newNode);
  124. count++;
  125. return true;
  126. }
  127.  
  128. public boolean delete(int index)
  129. {
  130. if(index < 0 || index > count-1)
  131. return false;
  132. //delete the last node
  133. if(count == 1)
  134. {
  135. head = tail = null;
  136. count--;
  137. return true;
  138. }
  139.  
  140. //delete the first node
  141. if(index == 0)
  142. {
  143. head = head.getNext();
  144. head.setPrev(null);
  145. count--;
  146. return true;
  147. }
  148.  
  149. //delete the last node
  150. if(index == count-1)
  151. {
  152. tail = tail.getPrev();
  153. tail.setNext(null);
  154. count--;
  155. return true;
  156. }
  157.  
  158. //delete the middle node
  159. Node walker;
  160. if(index < (count/2))
  161. {
  162. walker = head;
  163. for(int i = 0; i < index-1; i++)
  164. walker = walker.getNext();
  165. }
  166. else
  167. {
  168. walker = tail;
  169. for(int i = 0; i < (count-index); i++)
  170. walker = walker.getPrev();
  171. }
  172. walker.getNext().getNext().setPrev(walker);
  173. walker.setNext(walker.getNext().getNext());
  174. count--;
  175. return true;
  176. }
  177. }
  1. import java.util.Random;
  2.  
  3. public class ListTest
  4. {
  5. public static void main(String args[])
  6. {
  7. Random r = new Random();
  8.  
  9. List l = new List();
  10.  
  11. //insert elements
  12. for(int i = 0; i < 10; i++)
  13. l.insert(r.nextInt(100), i);
  14.  
  15. System.out.println("Size: "+l.getSize()+" - "+l);
  16.  
  17. //insert
  18. l.insert(100, 0);//insert in the front
  19. l.insert(200, 5);//insert in the middle
  20. l.insert(300, 12);//insert in the end
  21. System.out.println("Size: "+l.getSize()+" - "+l);
  22.  
  23. //delete
  24. l.delete(12);//delete the end
  25. l.delete(0);//delete the front
  26. l.delete(5);//delete the middle
  27. System.out.println("Size: "+l.getSize()+" - "+l);
  28.  
  29. for(int i = 0, len = l.getSize(); i < len; i++)
  30. {
  31. l.delete(0);
  32. System.out.println("Size: "+l.getSize()+" - "+l);;
  33. }
  34. }
  35. }