Source of DoublyLinkedList.java


  1: //DoublyLinkedList.java

  3: class Node
  4: {
  5:     public int data;
  6:     public Node next;
  7:     public Node previous;

  9:     public Node(int initialData)
 10:     {
 11:         data = initialData;
 12:         next = null;
 13:         previous = null;
 14:     }
 15: }

 17: class LinkedList
 18: {
 19:     private Node head;
 20:     private Node tail;

 22:     public LinkedList()
 23:     {
 24:         head = null;
 25:         tail = null;
 26:     }

 28:     public void append(Node newNode)
 29:     {
 30:         if (head == null)
 31:         {
 32:             head = newNode;
 33:             tail = newNode;
 34:         }
 35:         else
 36:         {
 37:             tail.next = newNode;
 38:             newNode.previous = tail;
 39:             tail = newNode;
 40:         }
 41:     }

 43:     public void prepend(Node newNode)
 44:     {
 45:         if (head == null)
 46:         {
 47:             head = newNode;
 48:             tail = newNode;
 49:         }
 50:         else
 51:         {
 52:             newNode.next = head;
 53:             head.previous = newNode;
 54:             head = newNode;
 55:         }
 56:     }

 58:     public void printList()
 59:     {
 60:         Node node = head;
 61:         while (node != null)
 62:         {
 63:             System.out.print(node.data + " ");
 64:             node = node.next;
 65:         }
 66:         System.out.println();
 67:     }

 69:     public void insertAfter
 70:     (
 71:         Node currentNode,
 72:         Node newNode
 73:     )
 74:     {
 75:         if (head == null)
 76:         {
 77:             head = newNode;
 78:             tail = newNode;
 79:         }
 80:         else if (currentNode == tail)
 81:         {
 82:             tail.next = newNode;
 83:             newNode.previous = tail;
 84:             tail = newNode;
 85:         }
 86:         else
 87:         {
 88:             Node successor = currentNode.next;
 89:             newNode.next = successor;
 90:             newNode.previous = currentNode;
 91:             currentNode.next = newNode;
 92:             successor.previous = newNode;
 93:         }
 94:     }

 96:     public void remove(Node currentNode)
 97:     {
 98:         Node successor = currentNode.next;
 99:         Node predecessor = currentNode.previous;

101:         if (successor != null)
102:             successor.previous = predecessor;

104:         if (predecessor != null)
105:             predecessor.next = successor;

107:         if (currentNode == head)
108:             head = successor;

110:         if (currentNode == tail)
111:             tail = predecessor;
112:     }
113: }