CC-13 : Delete adjacent nodes.

Below fully running code can be copied and run on Eclipse or other Java IDEs. Refer the classname in code below. If the class name below is "A", save the code below to a file named A.java before running it. Be sure to try your own test cases to enhance your understanding ! You can also tweak the code to optimize or add enhancements and custom features.

Note: For easier code execution and easier reference, the class below contains code for DoubleLInkedList and DoubleLinkedListNode as internal classes. Ideally both these classes should be separate public classes.

public class DoubleLinkedListDeleteAdjacent {
	
		
public void doubleLinkedListDeleteNumAndAdjacent(DoubleLinkedList doubleLinkedList, int toDelete) {
	try {
		DoubleLinkedListNode currentNode=doubleLinkedList.getFirstNode();
		while ((currentNode !=null) && (currentNode.getNodeData() != toDelete)) {
		  	currentNode=currentNode.getNextNode();
		 }
		if (currentNode==null) {return;}
		DoubleLinkedListNode prevNode=null; DoubleLinkedListNode prevToPrevNode=null;
		DoubleLinkedListNode nextNode=null; DoubleLinkedListNode nextToNextNode=null;
		if (currentNode.getPreviousNode() != null) {
			prevNode=currentNode.getPreviousNode();
			if (prevNode.getPreviousNode() != null) {
				prevToPrevNode=prevNode.getPreviousNode();
			}				
		}
		if (currentNode.getNextNode() != null) {
			nextNode=currentNode.getNextNode();
			if (nextNode.getNextNode() != null) {
				nextToNextNode=nextNode.getNextNode();
			}				
		}
		if ((prevNode == null) || ((prevNode != null) && (prevToPrevNode==null))) {
			doubleLinkedList.setFirstNode(nextToNextNode);
			if(doubleLinkedList.getFirstNode() !=null) {
				doubleLinkedList.getFirstNode().setPreviousNode(null);
			}
			return;
		}
		if ((nextNode == null) || ((nextNode != null) && (nextToNextNode==null))) {
			prevToPrevNode.setNextNode(null);
			return;
		}
		if ((prevToPrevNode !=null)&&(nextToNextNode!=null)) {
			prevToPrevNode.setNextNode(nextToNextNode);
			nextToNextNode.setPreviousNode(prevToPrevNode);				
		}
	}catch (Exception exception) {
			System.out.print("Exception: "+ exception);			
	}
				
}

	

    
public static void main(String[] args) {
	
		
try {
	DoubleLinkedListDeleteAdjacent doubleLinkedListDeleteAdjacent=new DoubleLinkedListDeleteAdjacent();
	DoubleLinkedList doubleLinkedList=doubleLinkedListDeleteAdjacent.new DoubleLinkedList();
	
	
	doubleLinkedList.addFirst(5);
	doubleLinkedList.addFirst(4);
	doubleLinkedList.addFirst(2);
	doubleLinkedList.addFirst(3);
	doubleLinkedList.addFirst(9);
	doubleLinkedList.addFirst(33);
	doubleLinkedList.addFirst(6);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	System.out.println("Deleting 3");
doubleLinkedListDeleteAdjacent.doubleLinkedListDeleteNumAndAdjacent(doubleLinkedList, 3);
doubleLinkedList.printDoubleLinkListForwardDirection();

	
	doubleLinkedList.addFirst(44);
	doubleLinkedList.addFirst(66);
	doubleLinkedList.addFirst(99);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	System.out.println("Deleting 99");
	doubleLinkedListDeleteAdjacent.doubleLinkedListDeleteNumAndAdjacent(doubleLinkedList, 99);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	
	doubleLinkedList.addFirst(70);
	doubleLinkedList.addFirst(30);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	System.out.println("Deleting 5");
	doubleLinkedListDeleteAdjacent.doubleLinkedListDeleteNumAndAdjacent(doubleLinkedList, 5);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	
	doubleLinkedList.addFirst(27);
	doubleLinkedList.addFirst(24);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	System.out.println("Deleting 6");
	doubleLinkedListDeleteAdjacent.doubleLinkedListDeleteNumAndAdjacent(doubleLinkedList, 6);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	
	doubleLinkedList.addFirst(75);
	doubleLinkedList.addFirst(120);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	System.out.println("Deleting 75");
	doubleLinkedListDeleteAdjacent.doubleLinkedListDeleteNumAndAdjacent(doubleLinkedList, 75);
	doubleLinkedList.printDoubleLinkListForwardDirection();
	
}catch (Exception exception) {
	System.out.print("Exception: "+ exception);
			
}
				
}

class DoubleLinkedList {

private DoubleLinkedListNode firstNode=null;
	
public DoubleLinkedListNode getFirstNode() {
	return firstNode;
}

public void setFirstNode(DoubleLinkedListNode firstNode) {
	this.firstNode = firstNode;
}

public DoubleLinkedListNode getLastNode() {
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
  	while (currentNode !=null) {
  		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();
  	}
  	return prevNode;
}

public boolean addLast(int data){
	DoubleLinkedListNode node=new DoubleLinkedListNode();
	node.setNodeData(data);
	if (firstNode==null) { 
		firstNode=node; 
		node.setNextNode(null);
		node.setPreviousNode(null);
		return true;
	}
	else {
		DoubleLinkedListNode currentNode=firstNode;
		while (currentNode.getNextNode()!=null) {currentNode=currentNode.getNextNode();}
		node.setPreviousNode(currentNode);			
		currentNode.setNextNode(node);
		node.setNextNode(null);
		return true;			
	}
}
		
public boolean addFirst(int data){
	DoubleLinkedListNode node=new DoubleLinkedListNode();
	node.setNodeData(data);
	if (firstNode==null) { 
		firstNode=node; 
		node.setNextNode(null);
		node.setPreviousNode(null);
		return true;
	}else {
		node.setNextNode(firstNode);
		firstNode.setPreviousNode(node);
		firstNode=node; 
		node.setPreviousNode(null);
		return true;			
	}
}
	
public boolean add(int data, int pos){	
	int size=getSize();
	if ((pos<0) || (pos > size)) { return false;}
	if (pos==0) {
		addFirst(data);
		return true;
	}
	if (pos==size) {
		addLast(data);
		return true;
	}
	DoubleLinkedListNode node=new DoubleLinkedListNode();
	node.setNodeData(data);
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
	int idx=0;
	while (currentNode !=null) {
	  	if ((idx==pos)){
	  		node.setNextNode(prevNode.getNextNode());
	  		prevNode.setNextNode(node);
	  	  	//setup previous node linkages
	  	  	node.getNextNode().setPreviousNode(node);
	  	  	node.setPreviousNode(prevNode);
	  	  	return true;
	  	  }
	  	prevNode=currentNode;
	  	currentNode=currentNode.getNextNode();
	  	idx++;
	  }  	
	  return false;  	
}	

public int getSize() {
	DoubleLinkedListNode currentNode=firstNode;
  	int idx=0;
  	while (currentNode !=null) {
  		currentNode=currentNode.getNextNode();
  		idx++;
  	}
  	return idx;
}	

public boolean removeFirst() {
	if (firstNode == null) { return false; }
	if (firstNode.getNextNode()==null) {
		firstNode=null; 
		return true;
	}
	firstNode=firstNode.getNextNode(); 
	firstNode.setPreviousNode(null);
	return true;
}

public boolean removeLast() {
	if (firstNode == null) { return false; }
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
	while (currentNode !=null) {
		if (currentNode.getNextNode()==null) {
			if (prevNode==null) {
				firstNode=null;
				return true;
			}
  			prevNode.setNextNode(null);
  			currentNode.setPreviousNode(null);
  			return true;
		}
		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();    		
  	}	
	return false;
}

public boolean remove(int data){	
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
  	while (currentNode !=null) {
  		if (currentNode.getNodeData() == data) {
  			if (prevNode==null) {
  				removeFirst();
  				return true;
  			}
  			if (currentNode.getNextNode()==null) {
  				removeLast();
  				return true;
  			}
  			prevNode.setNextNode(currentNode.getNextNode());
  			prevNode.getNextNode().setPreviousNode(prevNode);
  			return true;
  		}
  		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();  		
  	}  	
  	return false;  	
 }	

public boolean removeAtPos(int pos){	
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
  	int idx=0;
  	while (currentNode !=null) {
  		if (idx==pos) {
  			if (prevNode==null) {
  				removeFirst();
  				return true;
  			}
  			if (currentNode.getNextNode()==null) {
  				removeLast();
  				return true;
  			}
  			prevNode.setNextNode(currentNode.getNextNode());
  			return true;
  		}
  		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();  
  		idx++;
  	}  	
  	return false;  	  	
 }		

public int get(int idx) {
	DoubleLinkedListNode currentNode=firstNode;
  	int currIdx=0;
  	while (currentNode !=null) {
  		if (currIdx==idx) {return currentNode.getNodeData();}
  		currentNode=currentNode.getNextNode();
  		currIdx++;
  	}
  	return Integer.MIN_VALUE;
}

public void traverseForward() {
	DoubleLinkedListNode currentNode=firstNode;
	while (currentNode !=null) {
  		System.out.println(currentNode.getNodeData());
  		currentNode=currentNode.getNextNode();
  	}
}
			
	// print DoubleLinkList forward direction
 public void printDoubleLinkListForwardDirection() throws Exception    {
	// Case 1: The Linked list is empty !!
	if (firstNode == null) { System.out.println("Double Linked list empty"); return; }
	// Case 2: Print Double LinkedList node by node (first to last)
	DoubleLinkedListNode currentNode=firstNode;
	System.out.println();
	System.out.println("****************************************************************************");
	System.out.print("DoubleLinkedList nodes (first node to last node): ");
	do  {
		    System.out.print(currentNode.getNodeData());
		    if (currentNode.getNextNode()!=null)  System.out.print(" -> ");
			currentNode=currentNode.getNextNode();
			
		} while( currentNode != null);
	
		System.out.println();
		System.out.println("****************************************************************************");
		System.out.println();
		Thread.sleep(2000);
		;
		return;
	}
    
 // print DoubleLinkList backward direction
    public void printDoubleLinkListBackwardDirection() throws Exception    {
    	// Case 1: The Linked list is empty !!
    	if (firstNode == null) { System.out.println("Double Linked list empty"); return; }
    	// Case 2: Print Double LinkedList node by node (last to first)
    	// This while loop executes till we reach last node in the LinkedList
    	DoubleLinkedListNode currentNode=firstNode;
		while (currentNode.getNextNode()!=null) {currentNode=currentNode.getNextNode();}
		//currentNode is at end of LinkedList	
		System.out.println();
		System.out.println("****************************************************************************");
		System.out.print("DoubleLinkedList nodes (last node to first node): ");
		do  {
			    System.out.print(currentNode.getNodeData());
			    if (currentNode != firstNode)  System.out.print(" -> ");
				currentNode=currentNode.getPreviousNode();
				
			} while( currentNode != null);
		
			System.out.println();
			System.out.println("****************************************************************************");
			System.out.println();
			Thread.sleep(2000);
			;
			return;
	}

}


class DoubleLinkedListNode  {
	private DoubleLinkedListNode nextNode=null;
	private DoubleLinkedListNode previousNode=null;
	
	private int nodeData=0;

	public DoubleLinkedListNode getNextNode() {
		return nextNode;
	}
	public void setNextNode(DoubleLinkedListNode nextNode) {
		this.nextNode = nextNode;
	}
	public DoubleLinkedListNode getPreviousNode() {
		return previousNode;
	}
	public void setPreviousNode(DoubleLinkedListNode previousNode) {
		this.previousNode = previousNode;
	}
	public int getNodeData() {
		return nodeData;
	}
	public void setNodeData(int nodeData) {
		this.nodeData = nodeData;
	}
}

		
}