How to remove a node from a Singly Linked List at a given position in Java?

In a previous couple of posts, We Learned How to remove/delete first and the last Node from Singly Linked List.

In this post, We will learn How to remove/delete a node from a Singly Linked List at a given position in Java?

Program Logic:

if position == 0 then move head node to next node (head = head.next)
if position < 0 Or position > = number of nodes in Linked List then throws an Exception
We have to set a pointer to the node previous to the node to be deleted. So if the position is not zero then we have to run a loop position-1 times and get a pointer to the previous node.

package com.kkjavatutorials.util;

import java.util.NoSuchElementException;
/**
 * How to remove a node from a Singly Linked List at a given position in Java ?
 * @author KK JavaTutorials
 */
public class LinkedList<T> {
	
	private Node<T> head;
	
	//This internal class represents Node in Linked List
	private static class Node<T>{
		
		private T data;
		private Node<T> next;
		public Node(T data) {
			super();
			this.data = data;
			this.next = null;
		}
	}
	
	/**
	 * This method insert a Node in Linked List
	 * @param data has to insert in the List
	 */
	public void insert(T data) {
		Node<T> newNode = new Node<T>(data);
		if(head == null) {
			head = newNode;
		}else {
			Node<T> currentNode = head;
			while (currentNode.next != null) {
				currentNode = currentNode.next;
			}
			 currentNode.next = newNode;
		}
	}
	
    /**
     * Remove/delete the element at the specified position in this list.
     * I will Return the element that is removed from the list.
     * @param position the index of the element to be removed
     * @return the element removed Element
     * @throws IllegalArgumentException
     * 
     *  0 --First Node
     *  1-- Second Node
     *  2--Third Node
     */
    public T remove(int position) {
    	
    	T result = null;
    	if(head == null) {
			throw new NoSuchElementException("List is Empty!!");
		}
    	
    	/**
		 * if insert position is negative then throw
		 * IllegalArgumentException
		 */
		if(position<0) {
			throw new IllegalArgumentException("Invalid Value of position ="+position);
		}
		
		/**
		 * if node insertion position is greater
		 * than number of nodes then
		 *  throw IllegalArgumentException
		 */
		if(position > size()-1) {
			throw new IllegalArgumentException("Valus of position ="+position+" is greater than number of nodes in the list!!");
		}
		
		if(position == 0) {
			head = head.next;
			result = head.data;
			return result;
		}
		
		Node<T> previousNode = head;
		int count = 0;
		while(count < position-1) {
			previousNode = previousNode.next;
			count++;
		}
		
		Node<T> currentNode = previousNode.next;
		previousNode.next = currentNode.next;
		result = currentNode.data;
		currentNode.next = null;
		
		return result;
    }
	
    /**
	 * This method returns size/length of Linked List
	 * @return size of Linked List
	 */
	public int size() {
		int length = 0;
		if(head ==  null) {
			return length;
		}
		
		Node<T> currentNode = head;
		while (currentNode != null) {
			length ++;
			currentNode = currentNode.next;
		}
		return length;
	}
	
	/**
	 * Method which traverse Linked List and display all data.
	 */
	public void displayLinkedList() {
		Node<T> currentNode = head;
		while(currentNode!= null) {
			System.out.print(currentNode.data+" ");
			currentNode = currentNode.next;
		}
	}
	
	public static void main(String[] args) {
		
		LinkedList<Integer> linkedList = new LinkedList<>();
		linkedList.insert(10);
		linkedList.insert(20);
		linkedList.insert(30);
		linkedList.insert(40);
		linkedList.insert(50);
		linkedList.insert(60);
		
		System.out.println("Original LinkedList:");
		linkedList.displayLinkedList();
		System.out.println();
		
		int position = 2;
		linkedList.remove(position);
		System.out.println("After removing an Element from given position = "+position+" LinkedList is:");
		linkedList.displayLinkedList();
		
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145