CC-8 : Delete nodes of SingleLinkedList.

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.

public class SingleLinkedListDeleteNode {
	
	
public void singleLinkedListDeleteNode(SingleLinkedListNode toDelete) throws Exception{
	SingleLinkedListNode nextNode=toDelete.getNextNode();
	System.out.println("Next Node Data"+nextNode.getNodeData());
	toDelete.setNodeData(nextNode.getNodeData());
	System.out.println("Delete Node Data after getting data from next node"+toDelete.getNodeData());
	toDelete.setNextNode(nextNode.getNextNode());
	System.out.println("Next node of to Delete after getting data from next node"+toDelete.getNextNode());
	nextNode.setNextNode(null);
	return;
}
	

    
public static void main(String[] args) {
			
	try {
	SingleLinkedListDeleteNode singleLinkedListDeleteNode=new SingleLinkedListDeleteNode();
	SingleLinkedList singleLinkedList=singleLinkedListDeleteNode.new SingleLinkedList();
	SingleLinkedListNode node1=singleLinkedListDeleteNode.new SingleLinkedListNode();
	node1.setNodeData(1);
	singleLinkedList.setFirstNode(node1);
	SingleLinkedListNode node2=singleLinkedListDeleteNode.new SingleLinkedListNode();
	node2.setNodeData(2);
	node1.setNextNode(node2);
	SingleLinkedListNode node3=singleLinkedListDeleteNode.new SingleLinkedListNode();
	node3.setNodeData(3);
	node2.setNextNode(node3);
	SingleLinkedListNode node4=singleLinkedListDeleteNode.new SingleLinkedListNode();
	node4.setNodeData(4);
	node3.setNextNode(node4);
	SingleLinkedListNode node5=singleLinkedListDeleteNode.new SingleLinkedListNode();
	node5.setNodeData(5);
	node4.setNextNode(node5);
	SingleLinkedListNode node6=singleLinkedListDeleteNode.new SingleLinkedListNode();
	node6.setNodeData(6);
	node5.setNextNode(node6);
	singleLinkedList.printSingleLinkList();
	System.out.println("Deleting 1");
	singleLinkedListDeleteNode.singleLinkedListDeleteNode(node1);
	singleLinkedList.printSingleLinkList();
	System.out.println("Deleting 2");
	singleLinkedListDeleteNode.singleLinkedListDeleteNode(node2);
	singleLinkedList.printSingleLinkList();
	System.out.println("Deleting 5");
	singleLinkedListDeleteNode.singleLinkedListDeleteNode(node5);
	singleLinkedList.printSingleLinkList();
	System.out.println("Deleting 4");
	singleLinkedListDeleteNode.singleLinkedListDeleteNode(node4);
		
	    
	}catch (Exception exception) {
		 exception.printStackTrace();
	}
			
}



class SingleLinkedList {
	
private SingleLinkedListNode firstNode=null;

public SingleLinkedListNode getFirstNode() {
	return firstNode;
}

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

public boolean addLast(int data){
	SingleLinkedListNode node=new SingleLinkedListNode();
	node.setNodeData(data);
	if (firstNode==null) { 
		firstNode=node; 
		node.setNextNode(null);
		return true;
	}
	else {
		SingleLinkedListNode currentNode=firstNode;
		while (currentNode.getNextNode()!=null) {currentNode=currentNode.getNextNode();}
			currentNode.setNextNode(node);
			node.setNextNode(null);
			return true;			
	}
}
	
public boolean addFirst(int data){
	SingleLinkedListNode node=new SingleLinkedListNode();
	node.setNodeData(data);
	if (firstNode==null) { 
		firstNode=node; 
		node.setNextNode(null);
		return true;
	}
	else {
		node.setNextNode(firstNode);
		firstNode=node; 
		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;
	}
	SingleLinkedListNode node=new SingleLinkedListNode();
	node.setNodeData(data);
  	SingleLinkedListNode currentNode=firstNode;
  	SingleLinkedListNode prevNode=null;
  	int idx=0;
  	while (currentNode !=null) {
  		if ((idx==pos)){
  	  		node.setNextNode(prevNode.getNextNode());
  	  		prevNode.setNextNode(node);
  	  		return true;
  	  	}
  		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();
  		idx++;
  	}  	
  	return false;  	
 }	

public int getSize() {
	SingleLinkedListNode 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();
	return true;
}

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

public boolean remove(int data){	
	SingleLinkedListNode currentNode=firstNode;
  	SingleLinkedListNode 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());
  			return true;
  		}
  		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();  		
  	}  	
  	return false;  	
 }	

public boolean removeAtPos(int pos){	
	
	SingleLinkedListNode currentNode=firstNode;
  	SingleLinkedListNode 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) {
	SingleLinkedListNode currentNode=firstNode;
  	int currIdx=0;
  	while (currentNode !=null) {
  		if (currIdx==idx) {return currentNode.getNodeData();}
  		currentNode=currentNode.getNextNode();
  		currIdx++;
  	}
  	return Integer.MIN_VALUE;
}

public void traverse() {
	SingleLinkedListNode currentNode=firstNode;
	while (currentNode !=null) {
  		System.out.println(currentNode.getNodeData());
  		currentNode=currentNode.getNextNode();
  	}
}

			
	// print SingleLinkList
    public void printSingleLinkList() throws Exception    {
    	// Case 1: The Linked list is empty !!
    	if (firstNode == null) { System.out.println("Linked list empty"); return; }
    	// Case 2: Print LinkedList node by node
		SingleLinkedListNode currentNode=firstNode;
		System.out.println();
		System.out.println("*********************************************************************");
		System.out.print("SingleLinkedList nodes: ");
		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;
	}
}	

	
class SingleLinkedListNode  {
	
	private SingleLinkedListNode nextNode=null;
		
	//This is the data stored by Linked list. Replace it by String, array , or any other datatype as per need
	private int nodeData=0;
	

	public SingleLinkedListNode getNextNode() {
		return nextNode;
	}
	public void setNextNode(SingleLinkedListNode nextNode) {
		this.nextNode = nextNode;
	}

	
	public int getNodeData() {
		return nodeData;
	}
	public void setNodeData(int nodeData) {
		this.nodeData = nodeData;
	}
	
	
}	
	

}