import java.io.

*;

// Java program to implement

// a Singly Linked List
public class LinkedList {

Node head; // head of list

// Linked list Node.

// This inner class is made static
// so that main() can access it
static class Node {

int data;
Node next;

// Constructor
Node(int d)
{
data = d;
next = null;
}
}

// Method to insert a new node

public static LinkedList insert(LinkedList list, int data)
{
// Create a new node with given data
Node new_node = new Node(data);
new_node.next = null;

// If the Linked List is empty,

// then make the new node as head
if (list.head == null) {
list.head = new_node;
}
else {
// Else traverse till the last node
// and insert the new_node there
Node last = list.head;
while (last.next != null) {
last = last.next;
}

// Insert the new_node at last node

last.next = new_node;
}

// Return the list by head

return list;
}

// Method to print the LinkedList.

public static void printList(LinkedList list)
{
Node currNode = list.head;

System.out.print("LinkedList: ");
 // Traverse through the LinkedList
while (currNode != null) {
// Print the data at current node
System.out.print(currNode.data + " ");

// Go to next node
currNode = currNode.next;
}
}

// **************MAIN METHOD**************

// method to create a Singly linked list with n nodes

public static void main(String[] args)
{
/* Start with the empty list. */
LinkedList list = new LinkedList();

//
// ******INSERTION******
//

// Insert the values

list = insert(list, 1);
list = insert(list, 2);
list = insert(list, 3);
list = insert(list, 4);
list = insert(list, 5);
list = insert(list, 6);
list = insert(list, 7);
list = insert(list, 8);

// Print the LinkedList

printList(list);
}
}
Output:

LinkedList: 1 2 3 4 5 6 7 8

Deletion By KEY

The deletion process can be understood as follows:

To be done:
Given a �key�, delete the first occurrence of this key in linked list.

How to do it:
To delete a node from linked list, do following steps.

Search the key for its first occurrence in the list

Now, Any of the 3 conditions can be there:
Case 1: The key is found at head
In this case, Change the head of the node to the next node of current
head.
Free the memory of replaced head node.
Case 2: The key is found at in the middle or last, except at head
In this case, Find previous node of the node to be deleted.
 Change the next of previous node to the next node of current node.
Free the memory of replaced node.
Case 3: The key is not found in the list
In this case, No operation needs to be done.

linkedlist_deletion
filter_none

edit

play_arrow

brightness_4
import java.io.*;

// Java program to implement

// a Singly Linked List
public class LinkedList {

Node head; // head of list

// Linked list Node.

// This inner class is made static
// so that main() can access it
static class Node {

int data;
Node next;

// Constructor
Node(int d)
{
data = d;
next = null;
}
}

// Method to insert a new node

public static LinkedList insert(LinkedList list, int data)
{
// Create a new node with given data
Node new_node = new Node(data);
new_node.next = null;

// If the Linked List is empty,

// then make the new node as head
if (list.head == null) {
list.head = new_node;
}
else {
// Else traverse till the last node
// and insert the new_node there
Node last = list.head;
while (last.next != null) {
last = last.next;
}

// Insert the new_node at last node

last.next = new_node;
 }

// Return the list by head

return list;
}

// Method to print the LinkedList.

public static void printList(LinkedList list)
{
Node currNode = list.head;

System.out.print("LinkedList: ");

// Traverse through the LinkedList

while (currNode != null) {
// Print the data at current node
System.out.print(currNode.data + " ");

// Go to next node
currNode = currNode.next;
}

System.out.println();
}

// **************DELETION BY KEY**************

// Method to delete a node in the LinkedList by KEY

public static LinkedList deleteByKey(LinkedList list, int key)
{
// Store head node
Node currNode = list.head, prev = null;

//
// CASE 1:
// If head node itself holds the key to be deleted

if (currNode != null && currNode.data == key) {

list.head = currNode.next; // Changed head

// Display the message

System.out.println(key + " found and deleted");

// Return the updated List

return list;
}

//
// CASE 2:
// If the key is somewhere other than at head
//

// Search for the key to be deleted,

// keep track of the previous node
// as it is needed to change currNode.next
while (currNode != null && currNode.data != key) {
// If currNode does not hold key
// continue to next node
prev = currNode;
 currNode = currNode.next;
}

// If the key was present, it should be at currNode

// Therefore the currNode shall not be null
if (currNode != null) {
// Since the key is at currNode
// Unlink currNode from linked list
prev.next = currNode.next;

// Display the message

System.out.println(key + " found and deleted");
}

//
// CASE 3: The key is not present
//

// If key was not present in linked list

// currNode should be null
if (currNode == null) {
// Display the message
System.out.println(key + " not found");
}

// return the List

return list;
}

// **************MAIN METHOD**************

// method to create a Singly linked list with n nodes

public static void main(String[] args)
{
/* Start with the empty list. */
LinkedList list = new LinkedList();

//
// ******INSERTION******
//

// Insert the values

list = insert(list, 1);
list = insert(list, 2);
list = insert(list, 3);
list = insert(list, 4);
list = insert(list, 5);
list = insert(list, 6);
list = insert(list, 7);
list = insert(list, 8);

// Print the LinkedList

printList(list);

//
// ******DELETION BY KEY******
//

// Delete node with value 1

 // In this case the key is ***at head***
deleteByKey(list, 1);

// Print the LinkedList

printList(list);

// Delete node with value 4

// In this case the key is present ***in the middle***
deleteByKey(list, 4);

// Print the LinkedList

printList(list);

// Delete node with value 10

// In this case the key is ***not present***
deleteByKey(list, 10);

// Print the LinkedList

printList(list);
}
}
Output:

LinkedList: 1 2 3 4 5 6 7 8
1 found and deleted
LinkedList: 2 3 4 5 6 7 8
4 found and deleted
LinkedList: 2 3 5 6 7 8
10 not found
LinkedList: 2 3 5 6 7 8

Deletion At Position

This deletion process can be understood as follows:

To be done:
Given a �position�, delete the node at this position from the linked list.

How to do it:
The steps to do it are as follows:

Traverse the list by counting the index of the nodes

For each index, match the index to be same as position
Now, Any of the 3 conditions can be there:
Case 1: The position is 0, i.e. the head is to be deleted
In this case, Change the head of the node to the next node of current
head.
Free the memory of replaced head node.
Case 2: The position is greater than 0 but less than the size of the list,
i.e. in the middle or last, except at head
In this case, Find previous node of the node to be deleted.
Change the next of previous node to the next node of current node.
Free the memory of replaced node.
Case 3: The position is greater than the size of the list, i.e. position
not found in the list
In this case, No operation needs to be done.

linkedlist_deletion
filter_none
edit

play_arrow

brightness_4
import java.io.*;

// Java program to implement

// a Singly Linked List
public class LinkedList {

Node head; // head of list

// Linked list Node.

// This inner class is made static
// so that main() can access it
static class Node {

int data;
Node next;

// Constructor
Node(int d)
{
data = d;
next = null;
}
}

// Method to insert a new node

public static LinkedList insert(LinkedList list, int data)
{
// Create a new node with given data
Node new_node = new Node(data);
new_node.next = null;

// If the Linked List is empty,

// then make the new node as head
if (list.head == null) {
list.head = new_node;
}
else {
// Else traverse till the last node
// and insert the new_node there
Node last = list.head;
while (last.next != null) {
last = last.next;
}

// Insert the new_node at last node

last.next = new_node;
}

// Return the list by head

return list;
}

// Method to print the LinkedList.

public static void printList(LinkedList list)
{
Node currNode = list.head;

System.out.print("LinkedList: ");

// Traverse through the LinkedList

while (currNode != null) {
// Print the data at current node
System.out.print(currNode.data + " ");

// Go to next node
currNode = currNode.next;
}

System.out.println();
}

// Method to delete a node in the LinkedList by POSITION

public static LinkedList deleteAtPosition(LinkedList list, int index)
{
// Store head node
Node currNode = list.head, prev = null;

//
// CASE 1:
// If index is 0, then head node itself is to be deleted

if (index == 0 && currNode != null) {

list.head = currNode.next; // Changed head

// Display the message

System.out.println(index + " position element deleted");

// Return the updated List

return list;
}

//
// CASE 2:
// If the index is greater than 0 but less than the size of LinkedList
//
// The counter
int counter = 0;

// Count for the index to be deleted,

// keep track of the previous node
// as it is needed to change currNode.next
while (currNode != null) {

if (counter == index) {
// Since the currNode is the required position
// Unlink currNode from linked list
prev.next = currNode.next;

// Display the message

System.out.println(index + " position element deleted");
break;
}
 else {
// If current position is not the index
// continue to next node
prev = currNode;
currNode = currNode.next;
counter++;
}
}

// If the position element was found, it should be at currNode

// Therefore the currNode shall not be null
//
// CASE 3: The index is greater than the size of the LinkedList
//
// In this case, the currNode should be null
if (currNode == null) {
// Display the message
System.out.println(index + " position element not found");
}

// return the List

return list;
}

// **************MAIN METHOD**************

// method to create a Singly linked list with n nodes

public static void main(String[] args)
{
/* Start with the empty list. */
LinkedList list = new LinkedList();

//
// ******INSERTION******
//

// Insert the values

list = insert(list, 1);
list = insert(list, 2);
list = insert(list, 3);
list = insert(list, 4);
list = insert(list, 5);
list = insert(list, 6);
list = insert(list, 7);
list = insert(list, 8);

// Print the LinkedList

printList(list);

//
// ******DELETION AT POSITION******
//

// Delete node at position 0

// In this case the key is ***at head***
deleteAtPosition(list, 0);

// Print the LinkedList

printList(list);
 // Delete node at position 2
// In this case the key is present ***in the middle***
deleteAtPosition(list, 2);

// Print the LinkedList

printList(list);

// Delete node at position 10

// In this case the key is ***not present***
deleteAtPosition(list, 10);

// Print the LinkedList

printList(list);
}
}
Output:

LinkedList: 1 2 3 4 5 6 7 8
0 position element deleted
LinkedList: 2 3 4 5 6 7 8
2 position element deleted
LinkedList: 2 3 5 6 7 8
10 position element not found
LinkedList: 2 3 5 6 7 8

All Operations

Below is the complete program that applies each operations together:

filter_none

edit

play_arrow

brightness_4
import java.io.*;

// Java program to implement

// a Singly Linked List
public class LinkedList {

Node head; // head of list

// Linked list Node.

// This inner class is made static
// so that main() can access it
static class Node {

int data;
Node next;

// Constructor
Node(int d)
{
data = d;
next = null;
}
}
// **************INSERTION**************

// Method to insert a new node

public static LinkedList insert(LinkedList list, int data)
{
// Create a new node with given data
Node new_node = new Node(data);
new_node.next = null;

// If the Linked List is empty,

// then make the new node as head
if (list.head == null) {
list.head = new_node;
}
else {
// Else traverse till the last node
// and insert the new_node there
Node last = list.head;
while (last.next != null) {
last = last.next;
}

// Insert the new_node at last node

last.next = new_node;
}

// Return the list by head

return list;
}

// **************TRAVERSAL**************

// Method to print the LinkedList.

public static void printList(LinkedList list)
{
Node currNode = list.head;

System.out.print("\nLinkedList: ");

// Traverse through the LinkedList

while (currNode != null) {
// Print the data at current node
System.out.print(currNode.data + " ");

// Go to next node
currNode = currNode.next;
}
System.out.println("\n");
}

// **************DELETION BY KEY**************

// Method to delete a node in the LinkedList by KEY

public static LinkedList deleteByKey(LinkedList list, int key)
{
// Store head node
Node currNode = list.head, prev = null;
 //
// CASE 1:
// If head node itself holds the key to be deleted

if (currNode != null && currNode.data == key) {

list.head = currNode.next; // Changed head

// Display the message

System.out.println(key + " found and deleted");

// Return the updated List

return list;
}

//
// CASE 2:
// If the key is somewhere other than at head
//

// Search for the key to be deleted,

// keep track of the previous node
// as it is needed to change currNode.next
while (currNode != null && currNode.data != key) {
// If currNode does not hold key
// continue to next node
prev = currNode;
currNode = currNode.next;
}

// If the key was present, it should be at currNode

// Therefore the currNode shall not be null
if (currNode != null) {
// Since the key is at currNode
// Unlink currNode from linked list
prev.next = currNode.next;

// Display the message

System.out.println(key + " found and deleted");
}

//
// CASE 3: The key is not present
//

// If key was not present in linked list

// currNode should be null
if (currNode == null) {
// Display the message
System.out.println(key + " not found");
}

// return the List

return list;
}

// **************DELETION AT A POSITION**************

// Method to delete a node in the LinkedList by POSITION

public static LinkedList deleteAtPosition(LinkedList list, int index)
{
// Store head node
Node currNode = list.head, prev = null;

//
// CASE 1:
// If index is 0, then head node itself is to be deleted

if (index == 0 && currNode != null) {

list.head = currNode.next; // Changed head

// Display the message

System.out.println(index + " position element deleted");

// Return the updated List

return list;
}

//
// CASE 2:
// If the index is greater than 0 but less than the size of LinkedList
//
// The counter
int counter = 0;

// Count for the index to be deleted,

// keep track of the previous node
// as it is needed to change currNode.next
while (currNode != null) {

if (counter == index) {
// Since the currNode is the required position
// Unlink currNode from linked list
prev.next = currNode.next;

// Display the message

System.out.println(index + " position element deleted");
break;
}
else {
// If current position is not the index
// continue to next node
prev = currNode;
currNode = currNode.next;
counter++;
}
}

// If the position element was found, it should be at currNode

// Therefore the currNode shall not be null
//
// CASE 3: The index is greater than the size of the LinkedList
//
// In this case, the currNode should be null
if (currNode == null) {
// Display the message
System.out.println(index + " position element not found");
}
 // return the List
return list;
}

// **************MAIN METHOD**************

// method to create a Singly linked list with n nodes

public static void main(String[] args)
{
/* Start with the empty list. */
LinkedList list = new LinkedList();

//
// ******INSERTION******
//

// Insert the values

list = insert(list, 1);
list = insert(list, 2);
list = insert(list, 3);
list = insert(list, 4);
list = insert(list, 5);
list = insert(list, 6);
list = insert(list, 7);
list = insert(list, 8);

// Print the LinkedList

printList(list);

//
// ******DELETION BY KEY******
//

// Delete node with value 1

// In this case the key is ***at head***
deleteByKey(list, 1);

// Print the LinkedList

printList(list);

// Delete node with value 4

// In this case the key is present ***in the middle***
deleteByKey(list, 4);

// Print the LinkedList

printList(list);

// Delete node with value 10

// In this case the key is ***not present***
deleteByKey(list, 10);

// Print the LinkedList

printList(list);

//
// ******DELETION AT POSITION******
//

// Delete node at position 0

 // In this case the key is ***at head***
deleteAtPosition(list, 0);

// Print the LinkedList

printList(list);

// Delete node at position 2

// In this case the key is present ***in the middle***
deleteAtPosition(list, 2);

// Print the LinkedList

printList(list);

// Delete node at position 10

// In this case the key is ***not present***
deleteAtPosition(list, 10);

// Print the LinkedList

printList(list);
}
}
Output:

LinkedList: 1 2 3 4 5 6 7 8

1 found and deleted

LinkedList: 2 3 4 5 6 7 8

4 found and deleted

LinkedList: 2 3 5 6 7 8

10 not found

LinkedList: 2 3 5 6 7 8

0 position element deleted

LinkedList: 3 5 6 7 8

2 position element deleted

LinkedList: 3 5 7 8

10 position element not found

LinkedList: 3 5 7 8

Recommended Posts:

Implementing Iterator pattern of a single Linked List

XOR Linked List � A Memory Efficient Doubly Linked List | Set 2
Difference between Singly linked list and Doubly linked list
Merge a linked list into another linked list at alternate positions
XOR Linked List - A Memory Efficient Doubly Linked List | Set 1
Convert singly linked list into circular linked list
 Java Program for Reverse a linked list
How to add element at first and last position of linked list in Java?
Find the middle of a given linked list in C and Java
Convert Singly Linked List to XOR Linked List
Check if a linked list is Circular Linked List
Implementing Checksum Using Java
Construct a Maximum Sum Linked List out of two Sorted Linked Lists having some
Common nodes
Java | Implementing Iterator and Iterable Interface
Partitioning a linked list around a given value and If we don't care about
making the elements of the list "stable"

RishabhPrabhu
Technical Content Engineer

If you like GeeksforGeeks and would like to contribute, you can also write an
article using contribute.geeksforgeeks.org or mail your article to
[email protected]. See your article appearing on the GeeksforGeeks main
page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the
"Improve Article" button below.

Article Tags : Data Structures

Java
Java Programs
Linked List
Java-Class and Object
Java-List-Programs
Practice Tags : Data Structures
Java-Class and Object
Linked List
Java

thumb_up
1
1

Based on 1 vote(s)
Please write to us at [email protected] to report any issue with the
above content.
Post navigation
Previous
first_page Deque addFirst() method in Java with Examples
Next
last_page
Recursive Approach to find nth node from the end in the linked list

Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share
the link here.

Most popular in Data Structures

 Building Expression tree from Prefix Expression
Product of all nodes in a Binary Tree
Finding the path from one vertex to rest using BFS
Number of subarrays have bitwise OR >= K
Root to leaf path product equal to a given number

Most visited in Java

How to get rid of Java TLE problem

How do I become a good Java programmer?
Sorting in Java
Max Heap in Java
Bitwise operators in Java

Related Articles

Find minimum and maximum elements in singly Circular Linked List

Python program to find middle of a linked list using one traversal
Program to convert String to IntStream in Java
Unreachable statement using final and non-final variable in Java
Difference between ArrayList and HashSet in Java
Students with maximum average score of three subjects
Amazon SDE-2 Interview Experience
Product of the alternate nodes of linked list
Print nodes of linked list at given indexes
Java program to merge contents of all the files in a directory
OOPS | Generalization as extension and restriction using Java
Reverse a LinkedList in Java
Find the common nodes in two singly linked list
Delete linked list nodes which have a Lesser Value on Left Side
Recursively Reversing a linked list (A simple implementation)

Advertise Here