Doubly Linked List Program in Java

Doubly linked list programs are very complex programs to understand because the node of the doubly linked list contains two fields, previous and next. In C and C++, it is very easy to maintain a doubly linked list using pointers, but in Java, there is no concept of pointer that makes its construction a little bit tricky. A doubly linked list program can be of creating a doubly-linked list, inserting a node, or deleting a node.

Let's understand some basic programs of doubly linked list:

Creating a doubly linked list

For creating a node, we have to create a class for creating a Node type. The class contains three properties, i.e., data, prev, and next. The data can be of int, String, or float and prev and next are of the Node type. The user stores the information, and prev and next contain the previous and next nodes of the doubly linked list. In the given program, each line of code is defined through comments so that you can understand the code easily.

CreateDoublyLinkedList.java

public class CreateDoublyLinkedList {  

	//Create a node for doubly linked list  
	class Node{  
		String data;  
		Node prev;  
		Node next;  

		public Node(String data) {  
			this.data = data;  
		}  
	}  

	//Initialize head and tail for the doubly linked list  
	Node head = null;
	Node tail = null;  

	//Create addNewNode() method to add a node into a list 
	public void addNewNode(String data) {  

		//Create node  
		Node newNode = new Node(data);  

		//Check whether our doubly linked list is empty or not 
		if(head == null) {
			//The newNode is pointed by both head or tail 
			head = newNode;
			tail = newNode;
			//It is first node so prev will point to null  
			head.prev = null;  
			//It is also last node so tail's next will point to null  
			tail.next = null;  
		}
		//Execute when the doubly linked list is not empty
		else {  

			//The newly created node will be the last node, so now tail's next will point to that newly created node
			tail.next = newNode;  
			//The tail is pointing to the second last node so the newly created node's prev will point to tail  
			newNode.prev = tail;  
			//The newly created node will become new tail because it is last node in the doubly linked list 
			tail = newNode;  
			//The newly created node will be the last node so tail's next will be null  
			tail.next = null;  
		}  
	}  

	//Create showData() method for displaying data of doubly linked list  
	public void showData() {
		//intialize a new node current that will point to head  
		Node current = head;  
		//Check whether the doubly linked list is empty or not
		if(head == null) {
			//Print a statement and pass the control flow into the main() method
			System.out.println("List is empty");  
			return;  
		}
		//Print a statement
		System.out.println("Nodes of doubly linked list: ");  
		//Iterate the doubly linked list using while
		while(current != null) {  
			//Print tha data on that particular node and then increment the pointer for indicating next node  
			System.out.print(current.data + "\n");  
			current = current.next;  
		}  
	}  

	public static void main(String[] args) {  

		CreateDoublyLinkedList obj = new CreateDoublyLinkedList();  

		//Add nodes into the doubly linked list 
		obj.addNewNode("New York");  
		obj.addNewNode("Los Angeles");  
		obj.addNewNode("Chicago");  
		obj.addNewNode("Houston");  
		obj.addNewNode("Houston");  

		//Call showData() method for displaying doubly linked list data  
		obj.showData();  
	}  
}

Output:

Inserting a Node into a doubly-linked list

In the doubly linked list, a node can be inserted into one of the following ways:

At the beginning of the doubly linked list.
Add a node at the specified position.
Add a node at the end of the list.

We will understand all these ways by creating their programs one by one.

Insert a node in the beginning

In the CreateDoublyLinkedList example, the newly created node is added in the last of the doubly linked list. When we need to add a node at the beginning of the list, we need to change the value of the head node and the node which was pointed by that head. So, we will use the same example which we create above. We only add a method to that program for adding a node at the beginning of the list.

AddNodeInBeginning.java

public class AddNodeInBeginning {  

	//Creating a node for doubly linked list  
	class Node{  
		String data;  
		Node prev;  
		Node next;  

		public Node(String data) {  
			this.data = data;  
		}  
	}  

	//Initializing head and tail for the doubly linked list  
	Node head = null;
	Node tail = null;  
	
	public void addNewNodeInBegin(String data) {  
            //Creating node  
            Node newNode = new Node(data);  
              
            //Checking whether the list is empty or not  
            if(head == null) 
			{  
				//The newNode is pointed by both head or tail 
				head = newNode;
				tail = newNode;
				//It is first node so prev will point to null  
				head.prev = null;  
				//It is also last node so tail's next will point to null  
				tail.next = null;  
            }  
			////Execute when the list is not empty 
			else {  
				//The head's prev will point to the newNode  
				head.prev = newNode;  
				//The newNode's next will point to the head  
				newNode.next = head;  
				//The newNode's prev will point to null because it will be the first node 
				newNode.prev = null;  
				//The newNode will become new head because now the newly created node is the first node of the list 
				head = newNode;  
			}  
	}
	
	//Creating showData() method for displaying data of doubly linked list  
	public void showData() {
		//intializing a new node current that will point to head  
		Node current = head;  
		//Checking whether the doubly linked list is empty or not
		if(head == null) {
			//Printing a statement and pass the control flow into the main() method
			System.out.println("List is empty");  
			return;  
		}
		//Printing a statement
		System.out.println("Nodes of doubly linked list: ");  
		//Iterating the doubly linked list using while
		while(current != null) {  
			//Print tha data on that particular node and then increment the pointer for indicating next node  
			System.out.print(current.data + "\n");  
			current = current.next;  
		}  
	}  

	public static void main(String[] args) {  

		AddNodeInBeginning obj = new AddNodeInBeginning();  

		//Adding nodes into the doubly linked list 
		obj.addNewNodeInBegin("Emma");  
		obj.addNewNodeInBegin("Adele");  
		obj.addNewNodeInBegin("Aria");  
		obj.addNewNodeInBegin("Ally");  
		obj.addNewNodeInBegin("Paul");  
		
		
		//Calling showData() method for displaying doubly linked list data  
		obj.showData();  
	}  
}

Output:

Insert a node at the end

We can add a node at the end of the list too. In the CreateDoublyLinkedList program, each newly created node ad at the end of the list. So, we can say that the code of inserting a node at the end is already discussed before. But to make it more specific, we have given another example in which we create a separate method for adding a node.

AddNodeAtEnd.java

public class AddNodeAtEnd {  

	//Creating a node for list  
	class Node{  
		String data;  
		Node prev;  
		Node next;  

		public Node(String data) {  
			this.data = data;  
		}  
	}  

	//Initialize head and tail for the list  
	Node head = null;
	Node tail = null;  

	//Create firstNode() method for creating first node in the list
	public void firstNode(Node node){
		//The node will be pointed by both head and tail 
		head = node;
		tail = node;
		//It is first node so prev will point to null  
		head.prev = null;  
		//It is also last node so tail's next will point to null  
		tail.next = null;	
	}
	
	//Create addNewNodeAtEnd() method to add a node at last in the list   
	public void addNewNodeAtEnd(String data) {  
            //Creating new node  
            		Node newNode = new Node(data);  
              
            		//Check whether the list is empty or not  
            		if(head == null) 
		{  
			//Call firstNode() method to make it first node in the list
			firstNode(newNode);
			
            		}  
		////Execute when the list will not be empty 
		else {  
			//The newly created node will be the last node, so now tail's next will point to that newly created node
			tail.next = newNode;  
			//The tail will point to the second last node so the newly created node's prev will point to tail  
			newNode.prev = tail;  
			//The newly created node will become new tail because it is last node in the list 
			tail = newNode;  
			//The newly created node will be the last node so tail's next will be null  
			tail.next = null;  
		}  
	}
	
	//Creating showData() method for displaying data of list  
	public void showData() {
		//intialize a new node current that will point to head  
		Node current = head;  
		//Checking whether the list is empty or not
		if(head == null) {
			//Print a statement and pass the control flow into the main() method
			System.out.println("List is empty");  
			return;  
		}
		//Print a statement
		System.out.println("Nodes of doubly linked list: ");  
		//Iterate the list using while
		while(current != null) {  
			//Print tha data on that particular node and then increment the pointer to point to the next node  
			System.out.print(current.data + "\n");  
			current = current.next;  
		}  
	}  

	public static void main(String[] args) {  

		AddNodeAtEnd obj = new AddNodeAtEnd();  

		//Adding nodes at the end of the list 
		obj.addNewNodeAtEnd("New York");  
		obj.addNewNodeAtEnd("Chicago");  
		obj.addNewNodeAtEnd("Houston");  
		
		
		//Calling showData() method for displaying doubly linked list data  
		obj.showData();  
	}  
}  

Output:

Insert a node at the specified position

In order to create a program for adding a node at the specified position, we have to focus on the following four cases:

When the doubly linked list is empty, or the position is not available in the list.
The specified position can be 1, so we have to create the code for adding the node at the beginning of the list, which we discussed above.
The position can also be the last index or position in the doubly linked list. So, we also have to write the code for adding a node in the last of the list.
The last case is when the position is available somewhere in between the head and tail.

In the given code, we create separate methods for each case and try to make it as simple as possible.

AddNodeAtSpecifiedLocation.java

public class AddNodeAtSpecifiedLocation {  

	//Creating a node for the list  
	class Node{  
		String data;  
		Node prev;  
		Node next;  

		public Node(String data) {  
			this.data = data;  
		}  
	}  
	public int size = 0;  
	
	//Initializing head and tail for the list  
	Node head = null;
	Node tail = null;  

	//Create firstNode() method for creating first node in the list
	public void firstNode(Node node){
		//The node is pointed by both head or tail 
		head = node;
		tail = node;
		//It is first node so prev will point to null  
		head.prev = null;  
		//It is also last node so tail's next will point to null  
		tail.next = null;	
	}
	
	//Create lastNode() method for adding node at last in the list
	public void lastNode(Node node){
		//The tail's next will point to that node
		tail.next = node;  
		//The tail is pointing to the second last node so the newly created node's prev will point to tail  
		node.prev = tail;  
		//The newly created node will become new tail because it is last node in the doubly linked list 
		tail = node;  
		//The newly created node will be the last node so tail's next will be null  
		tail.next = null;	
	}
	
	//Create addNodeInBeginning() method for adding node at first position
	public void addNodeInBeginning(Node node){
		//The head's prev will point to the newNode  
		head.prev = node;  
		//The newNode's next will point to the head  
		node.next = head;  
		//The newNode's prev will point to null because it will be the first node 
		node.prev = null;  
		//The newNode will become new head because now the newly created node is the first node of the list 
		head = node;  	
	}
	
	//Creating addNewNode() method to add a node into a list 
	public void addNewNode(String data) {  

		//Creating node  
		Node newNode = new Node(data);  

		//Checking whether our list is empty or not 
		if(head == null) {
			//Call firstNode() method to create first node in the list
			firstNode(newNode);
		}
		//Execute when the list is not empty
		else {  
			//Call lastNode() method to add a node at last in the list 
			lastNode(newNode);
		}
		size++;
	}  
	
	public void addNodeToSpeciifiedPosition(int position, String data) {
		//Creating node  
		Node newNode = new Node(data);  

		//Checking whether our doubly linked list is empty or not 
		if(head == null) {
			System.out.println("The specified location is not available");
		}
		//Execute when the list is not empty
		else {
			if(position == size+1){
				
				//Call lastNode() method to add the node at last in the list 
				lastNode(newNode);
				
			}else if(position == 1){
				
				addNodeInBeginning(newNode);
				
			}else{
				//current node will point to head  
				Node current = head;
				Node temp = null; 
				
				//Iterate list till current points to the specified position  
				for(int i = 1; i < position-1; i++){  
					current = current.next;  
				}  
  
				//The temp node points to the node that is next to current  
				temp = current.next;  
				temp.prev = current;  
  
				//newNode will be added between current and temp  
				current.next = newNode;   
				newNode.prev = current;  
				newNode.next = temp;  
				temp.prev = newNode;  
			}  
			size++;
		}
	}
	
	//Creating showData() method for displaying data of doubly linked list  
	public void showData() {
		//intializing a new node current that will point to head  
		Node current = head;  
		//Checking whether the doubly linked list is empty or not
		if(head == null) {
			//Printing a statement and pass the control flow into the main() method
			System.out.println("List is empty");  
			return;  
		}
		//Printing a statement
		System.out.println("Nodes of doubly linked list: ");  
		//Iterating the doubly linked list using while
		while(current != null) {  
			//Print tha data on that particular node and then increment the pointer for indicating next node  
			System.out.print(current.data + "\n");  
			current = current.next;  
		}  
	}  

	public static void main(String[] args) {  

		AddNodeAtSpecifiedLocation obj = new AddNodeAtSpecifiedLocation();  

		//Adding nodes into the doubly linked list 
		obj.addNewNode("New York");  
		obj.addNewNode("Los Angeles");  
		obj.addNewNode("Chicago");  
		obj.addNewNode("Houston");  
		obj.addNewNode("Phoenix");  
		
		//Adding nodes at the specified position 
		obj.addNodeToSpeciifiedPosition(6, "Philadelphia");
		obj.addNodeToSpeciifiedPosition(1, "San Antonio");
		obj.addNodeToSpeciifiedPosition(3, "San Diego");
		
		//Calling showData() method for displaying doubly linked list data  
		obj.showData();  
	}  
}

Output:

Deleting a Node from a doubly linked list

For deleting a node, three cases are possible:

When the node is the first node in the list.
When the node is the last node in the list.
When the node is available in between the first and the last node.

In the given program, we have created three methods for these three different cases. Each line of code is described through comments in the program to make it easy to understand.

DeleteNodeFromList.java

public class DeleteNodeFromList {  

	//Create a node for DDL  
	class Node{  
		String data;  
		Node prev;  
		Node next;  

		public Node(String data) {  
			this.data = data;  
		}  
	}  

	int size = 0;
	
	//Initialize head and tail for DDL  
	Node head = null;
	Node tail = null;  

	
	
	//Create addNewNode() method to add a node into DDL 
	public void addNewNode(String data) {  

		//Creating node  
		Node newNode = new Node(data);  

		//Checking whether our DDL is empty or not 
		if(head == null) {
			//The newNode is pointed by both head or tail 
			head = newNode;
			tail = newNode;
			//It is first node so prev will point to null  
			head.prev = null;  
			//It is also last node so tail's next will point to null  
			tail.next = null;  
		}
		//Execute when the DDL is not empty
		else {  

			//The newly created node will be the last node, so now tail's next will point to that newly created node
			tail.next = newNode;  
			//The tail is pointing to the second last node so the newly created node's prev will point to tail  
			newNode.prev = tail;  
			//The newly created node will become new tail because it will be last node in the DDL 
			tail = newNode;  
			//The newly created node will be the last node so tail's next will be null  
			tail.next = null;  
		}
		//Increment the size of DDL
		size++;
	}
	
	//Create deleteFirstNode() method for deleting first node from DDL
	public void deleteFirstNode(){
		head = head.next;
	}
	
	//Create deleteLastNode() method for deleting last node from DDL
	public void deleteLastNode(){
		tail = tail.prev;
	}
	
	//Create deleteNodeAtSpecifiedLocation() method for deleting a node from DDL
	public void deleteNodeAtSpecifiedLocation(int position){

		//Check whether the DDL is empty or not 
		if(head == null || position>size) {
			System.out.println("\n" +position +"th position is not available\n");
		}
		//Execute when the DDL is not empty
		else {
			if(position == 1){
				
				//Call deleteFirstNode() method to delete first node from the DDL 
				deleteFirstNode();
				
				//Decrement the size of DDL
				size--;
				
			}else if(position == size){
				//Call deleteLastNode() method to delete last node from the DDL
				deleteLastNode();
				
				//Decrement the size of DDL
				size--;
				
			}else{
				//current node will point to head  
				Node current = head;
				
				//Iterate list till current points to the specified position  
				for(int i = 1; i < position; i++){  
					current = current.next;  
				} 
				
				//Delete node pointed by current
				current.next.prev = current.prev;
				current.prev.next = current.next;
			  
			}
			System.out.println(position +" node is deleted successfully from DDL");
		}
	}
	
	
	//Create showData() method for displaying data of DDL  
	public void showData() {
		//intialize a new node current that will point to head  
		Node current = head;  
		//Check whether the DDL is empty or not
		if(head == null) {
			//Print a statement and pass the control flow into the main() method
			System.out.println("List is empty");  
			return;  
		}
		//Print a statement
		System.out.println("Nodes of doubly linked list: ");  
		//Iterate the DDL using while
		while(current != null) {  
			//Print tha data on that particular node and then increment the pointer for indicating next node  
			System.out.print(current.data + "\n");  
			current = current.next;  
		}  
	}  

	public static void main(String[] args) {  

		DeleteNodeFromList obj = new DeleteNodeFromList();  

		//Add nodes into the DDL 
		obj.addNewNode("New York");  
		obj.addNewNode("Los Angeles");  
		obj.addNewNode("Chicago");  
		obj.addNewNode("Houston");  
		obj.addNewNode("Phoenix");  
		
		//Call showData() method for displaying DDL data  
		obj.showData();  
		
		//Delete nodes from the DDL
		obj.deleteNodeAtSpecifiedLocation(2);
		obj.deleteNodeAtSpecifiedLocation(1);
		obj.deleteNodeAtSpecifiedLocation(5);
		
		//Call showData() method for displaying DDL
		obj.showData();  
	}  
} 

Output: