Delete N nodes after M nodes of a linked list
Given an linked list our goal is to delete M nodes after N nodes. That is interesting because we can consider this problem in a two ways.
Consider situation 1: delete node Delete N nodes after M nodes, but in case if deleted last pair are not exist full N nodes. In this case we are also delete existing less than N nodes. For example.
Linked List : 1->2->3->4->5->6->7->NULL
Given M=1 , N=3 (deleted node sequence)
So pair of deleted node in this example
(2->3->4) Exactly 3 node delete
(6->7) Last pair are exist less than three nodes (In this method but this are deleted)
After Delete Linked List : 1->5->NULL
Suppose we are inserted the following (1,2,3,4,5,6,7,8,9,10) node in a sequence.
In this approach are assume there is possible to delete last sequence are less than given N nodes. If N nodes are exist then this will be deleted. In this case are not compulsory to delete N node complete pair is exist in last sequence.
Test case:Consider the following, test case.
1) When linked list are empty that means we can not delete any nodes. In this case display valid message (like linked list are empty) .
2) Assume that M and N are positive integers. If given value are less then or equal to zero then display valid message (Invalid M , N values).
3) Here M are used to skip node element and N are use to provide how many number of nodes are deleting. For example
Case 1:
Linked List : 1->2->3->4->5->6->NULL
Given M=3 , N=3 (deleted node sequence)
After Delete Linked List : 1->2->3->NULL
Case 2:
Linked List : 1->2->3->4->5->6->7->NULL
Given M=3 , N=3 (deleted node sequence)
After Delete Linked List : 1->2->3->7->NULL
(note that 7 is pair of M nodes)
Case 3:
Linked List : 1->2->3->4->5->6->7->8->9->NULL
Given M=2 , N=3 (deleted node sequence)
After Delete Linked List : 1->2->6->7->NULL
(Note that last deleted is not complete sequence of 3 nodes only two (8,9))


Here given code implementation process.
-
1) Delete n nodes after m nodes of a linked list in c
2) Delete n nodes after m nodes of a linked list in java
3) Delete n nodes after m nodes of a linked list in c++
4) Delete n nodes after m nodes of a linked list in go
5) Delete n nodes after m nodes of a linked list in c#
6) Delete n nodes after m nodes of a linked list in vb.net
7) Delete n nodes after m nodes of a linked list in php
8) Delete n nodes after m nodes of a linked list in python
9) Delete n nodes after m nodes of a linked list in ruby
10) Delete n nodes after m nodes of a linked list in scala
11) Delete n nodes after m nodes of a linked list in swift
12) Delete n nodes after m nodes of a linked list in kotlin
13) Delete n nodes after m nodes of a linked list in node
14) Delete n nodes after m nodes of a linked list in typeScript
Consider situation 2: Suppose you are write a algorithm which are restrically check delete N nodes of pair . If pair are have exactly N nodes then it will deleted otherwise not deleted this pair.
1) Firstly we are consider given linked list are not empty if there is empty then display valid message. and N and M are valid positive numbers.
2) When found deleted nodes first check this are contain N nodes or not. If N nodes are existing then deleting this nodes. Otherwise not deleting this pair of nodes.
Example 1:
Linked List : 1->2->3->4->5->6->7->NULL
Given M=1 , N=3 (deleted node sequence)
So pair of deleted node in this example
(2->3->4) Exactly 3 node delete
(6->7) Last pair are exist less than three nodes (Not deleted)
After Delete Linked List : 1->5->6->7->NULL
Example 2:
Linked List : 1->2->3->4->5->6->7->8->NULL
Given M=2 , N=2 (deleted node sequence)
After Delete Linked List : 1->2->5->6->NULL
Example 3:
Linked List : 1->2->3->4->5->6->7->8->9->NULL
Given M=2 , N=3 (deleted node sequence)
After Delete Linked List : 1->2->6->7->8->9->NULL
(Note that last deleted is not complete sequence of 3 nodes only two (8,9))
// Java Program
// Delete N nodes of after the M nodes set B
class Node
{
public int data;
public Node next;
public Node(int value)
{
this.data = value;
this.next = null;
}
}
public class LinkedList
{
public Node head;
// Class constructors
public LinkedList()
{
head = null;
}
// Insert new node at the last
public void insert(int value)
{
// Create new node
Node node = new Node(value);
if (head == null) head = node;
else
{
Node temp = head;
// find last node
while (temp.next != null)
{
// visit to next node
temp = temp.next;
}
// add node
temp.next = node;
}
}
// Display all Linked List elements
public void display()
{
if (this.head != null)
{
System.out.print("Linked List Element :");
Node temp = head;
while (temp != null)
{
System.out.print(" " + temp.data);
temp = temp.next;
}
}
else
{
System.out.println("Empty Linked list");
}
}
public void deleteNode(int m, int n)
{
if (this.head == null)
{
System.out.println("Empty Linked List");
}
else if (m <= 0 || n <= 0)
{
System.out.println("Invalid position");
}
else
{
int count = 0, find = 0;
Node temp = this.head, hold = null, current = null;
while (temp != null)
{
if (find < m)
{
//When need to skip element
find++;
hold = temp;
temp = temp.next;
if (find == m - 1 && temp != null)
{
current = temp.next;
find = 0;
// Check it out new deleted sequence are exist or not
while (current != null)
{
find++;
current = current.next;
if (find == n)
{
break;
}
}
if (find != n)
{
// When group of N nodes are not exist
// break the execution process
break;
}
else
{
find = m - 1;
}
}
}
else
{
temp = temp.next;
// Location is to find delete node
if (hold.next != null)
{
// When delete node is found
current = hold.next;
hold.next = current.next;
current = null;
}
count++;
if (count == n)
{
//reset the value
count = 0;
find = 0;
}
}
}
}
}
public static void main(String[] args)
{
int m = 2, n = 3;
LinkedList task = new LinkedList();
task.insert(1);
task.insert(2);
task.insert(3);
task.insert(4);
task.insert(5);
task.insert(6);
task.insert(7);
task.insert(8);
task.insert(9);
System.out.println("\nBefore Delete ");
task.display();
System.out.println("\n M: " + m + " N: " + n + " ");
System.out.println("After Delete ");
task.deleteNode(m, n);
task.display();
}
}
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
// Include header file
#include <iostream>
using namespace std;
// C++ Program
// Delete N nodes of after the M nodes set B
class Node
{
public: int data;
Node *next;
Node(int value)
{
this->data = value;
this->next = nullptr;
}
};
class LinkedList
{
public: Node *head;
// Class constructors
LinkedList()
{
this->head = nullptr;
}
// Insert new node at the last
void insert(int value)
{
// Create new node
Node *node = new Node(value);
if (this->head == nullptr)
{
this->head = node;
}
else
{
Node *temp = this->head;
// find last node
while (temp->next != nullptr)
{
// visit to next node
temp = temp->next;
}
// add node
temp->next = node;
}
}
// Display all Linked List elements
void display()
{
if (this->head != nullptr)
{
cout << "Linked List Element :";
Node *temp = this->head;
while (temp != nullptr)
{
cout << " " << temp->data;
temp = temp->next;
}
}
else
{
cout << "Empty Linked list" << endl;
}
}
void deleteNode(int m, int n)
{
if (this->head == nullptr)
{
cout << "Empty Linked List" << endl;
}
else if (m <= 0 || n <= 0)
{
cout << "Invalid position" << endl;
}
else
{
int count = 0;
int find = 0;
Node *temp = this->head;
Node *hold = nullptr;
Node *current = nullptr;
while (temp != nullptr)
{
if (find < m)
{
//When need to skip element
find++;
hold = temp;
temp = temp->next;
if (find == m - 1 && temp != nullptr)
{
current = temp->next;
find = 0;
// Check it out new deleted sequence are exist or not
while (current != nullptr)
{
find++;
current = current->next;
if (find == n)
{
break;
}
}
if (find != n)
{
// When group of N nodes are not exist
// break the execution process
break;
}
else
{
find = m - 1;
}
}
}
else
{
temp = temp->next;
// Location is to find delete node
if (hold->next != nullptr)
{
// When delete node is found
current = hold->next;
hold->next = current->next;
current = nullptr;
}
count++;
if (count == n)
{
//reset the value
count = 0;
find = 0;
}
}
}
}
}
};
int main()
{
int m = 2;
int n = 3;
LinkedList *task = new LinkedList();
task->insert(1);
task->insert(2);
task->insert(3);
task->insert(4);
task->insert(5);
task->insert(6);
task->insert(7);
task->insert(8);
task->insert(9);
cout << "\nBefore Delete " << endl;
task->display();
cout << "\n M: " << m << " N: " << n << " " << endl;
cout << "After Delete " << endl;
task->deleteNode(m, n);
task->display();
return 0;
}
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
package main
import "fmt"
// Go Program
// Delete N nodes of after the M nodes set B
type Node struct {
data int
next * Node
}
func getNode(value int) * Node {
return &Node {value,nil}
}
type LinkedList struct {
head * Node
}
func getLinkedList() * LinkedList {
return &LinkedList {nil}
}
// Insert new node at the last
func(this *LinkedList) insert(value int) {
// Create new node
var node * Node = getNode(value)
if this.head == nil {
this.head = node
} else {
var temp * Node = this.head
// find last node
for (temp.next != nil) {
// visit to next node
temp = temp.next
}
// add node
temp.next = node
}
}
// Display all Linked List elements
func(this LinkedList) display() {
if this.head != nil {
fmt.Print("Linked List Element :")
var temp * Node = this.head
for (temp != nil) {
fmt.Print(" ", temp.data)
temp = temp.next
}
} else {
fmt.Println("Empty Linked list")
}
}
func(this LinkedList) deleteNode(m, n int) {
if this.head == nil {
fmt.Println("Empty Linked List")
} else if m <= 0 || n <= 0 {
fmt.Println("Invalid position")
} else {
var count int = 0
var find int = 0
var temp * Node = this.head
var hold * Node = nil
var current * Node = nil
for (temp != nil) {
if find < m {
//When need to skip element
find++
hold = temp
temp = temp.next
if find == m - 1 && temp != nil {
current = temp.next
find = 0
// Check it out new deleted sequence are exist or not
for (current != nil) {
find++
current = current.next
if find == n {
break
}
}
if find != n {
// When group of N nodes are not exist
// break the execution process
break
} else {
find = m - 1
}
}
} else {
temp = temp.next
// Location is to find delete node
if hold.next != nil {
// When delete node is found
current = hold.next
hold.next = current.next
current = nil
}
count++
if count == n {
//reset the value
count = 0
find = 0
}
}
}
}
}
func main() {
var m int = 2
var n int = 3
var task * LinkedList = getLinkedList()
task.insert(1)
task.insert(2)
task.insert(3)
task.insert(4)
task.insert(5)
task.insert(6)
task.insert(7)
task.insert(8)
task.insert(9)
fmt.Println("\nBefore Delete ")
task.display()
fmt.Println("\n M: ", m, " N: ", n, " ")
fmt.Println("After Delete ")
task.deleteNode(m, n)
task.display()
}
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
//C Program to Delete node N nodes after M node
//method 2
#include<stdio.h>
#include <stdlib.h> //for malloc function
// Create structure
struct Node
{
int data;
struct Node *next;
};
// Function prototype
void insert(struct Node **, int);
void display(struct Node *);
void delete_node(struct Node *, int, int);
//insert Node element
void insert(struct Node **head, int value)
{
// Create dynamic node
struct Node *node = (struct Node *) malloc(sizeof(struct Node));
if (node == NULL)
{
printf("Memory overflow\n");
}
else
{
node->data = value;
node->next = NULL;
if ( *head == NULL)
{
*head = node;
}
else
{
struct Node *temp = *head;
// find last node
while (temp->next != NULL)
{
temp = temp->next;
}
// add node at last position
temp->next = node;
}
}
}
// display element of Node
void display(struct Node *temp)
{
if (temp == NULL)
{
printf("\nEmpty linked list");
}
while (temp != NULL)
{
printf("%d ", temp->data);
temp = temp->next;
}
}
// delete N nodes after M nodes
void delete_node(struct Node *head, int M, int N)
{
if (head == NULL)
{
printf("\nEmpty Linked List\n");
}
else if (M <= 0 || N <= 0)
{
printf("\nInvalid positions");
}
else
{
int count = 0, find = 0;
struct Node *temp = head, *hold = NULL, *current = NULL;
while (temp != NULL)
{
if (find < M)
{
// When need to skip element
find++;
hold = temp;
temp = temp->next;
if (find == M - 1 && temp != NULL)
{
current = temp->next;
find = 0;
// check it out new deleted sequence are exist or not
while (current != NULL)
{
find++;
current = current->next;
if (find == N)
{
break;
}
}
if (find != N)
{
// when group of N nodes are not exist
// break the execution process
break;
}
else
{
find = M - 1;
}
}
}
else
{
temp = temp->next;
// location is to find delete node
if (hold->next != NULL)
{
// when delete node is found
current = hold->next;
hold->next = current->next;
free(current);
current = NULL;
}
count++;
if (count == N)
{
// reset the value of find and count nodes
count = 0;
find = 0;
}
}
}
}
}
int main()
{
// Create node pointer
struct Node *head = NULL;
int m = 2, n = 3;
// Insert element of linked list
insert( &head, 1);
insert( &head, 2);
insert( &head, 3);
insert( &head, 4);
insert( &head, 5);
insert( &head, 6);
insert( &head, 7);
insert( &head, 8);
insert( &head, 9);
printf("Linked List :");
// Display all node
display(head);
printf("\n M = %d N = %d", m, n);
printf("\nAfter Remove Linked List : ");
delete_node(head, m, n);
display(head);
}
Output
Linked List :1 2 3 4 5 6 7 8 9
M = 2 N = 3
After Remove Linked List : 1 2 6 7 8 9
// Include namespace system
using System;
// Csharp Program
// Delete N nodes of after the M nodes set B
public class Node
{
public int data;
public Node next;
public Node(int value)
{
this.data = value;
this.next = null;
}
}
public class LinkedList
{
public Node head;
// Class constructors
public LinkedList()
{
this.head = null;
}
// Insert new node at the last
public void insert(int value)
{
// Create new node
var node = new Node(value);
if (this.head == null)
{
this.head = node;
}
else
{
var temp = this.head;
// find last node
while (temp.next != null)
{
// visit to next node
temp = temp.next;
}
// add node
temp.next = node;
}
}
// Display all Linked List elements
public void display()
{
if (this.head != null)
{
Console.Write("Linked List Element :");
var temp = this.head;
while (temp != null)
{
Console.Write(" " + temp.data.ToString());
temp = temp.next;
}
}
else
{
Console.WriteLine("Empty Linked list");
}
}
public void deleteNode(int m, int n)
{
if (this.head == null)
{
Console.WriteLine("Empty Linked List");
}
else if (m <= 0 || n <= 0)
{
Console.WriteLine("Invalid position");
}
else
{
var count = 0;
var find = 0;
var temp = this.head;
Node hold = null;
Node current = null;
while (temp != null)
{
if (find < m)
{
//When need to skip element
find++;
hold = temp;
temp = temp.next;
if (find == m - 1 && temp != null)
{
current = temp.next;
find = 0;
// Check it out new deleted sequence are exist or not
while (current != null)
{
find++;
current = current.next;
if (find == n)
{
break;
}
}
if (find != n)
{
// When group of N nodes are not exist
// break the execution process
break;
}
else
{
find = m - 1;
}
}
}
else
{
temp = temp.next;
// Location is to find delete node
if (hold.next != null)
{
// When delete node is found
current = hold.next;
hold.next = current.next;
current = null;
}
count++;
if (count == n)
{
//reset the value
count = 0;
find = 0;
}
}
}
}
}
public static void Main(String[] args)
{
var m = 2;
var n = 3;
var task = new LinkedList();
task.insert(1);
task.insert(2);
task.insert(3);
task.insert(4);
task.insert(5);
task.insert(6);
task.insert(7);
task.insert(8);
task.insert(9);
Console.WriteLine("\nBefore Delete ");
task.display();
Console.WriteLine("\n M: " + m.ToString() + " N: " + n.ToString() + " ");
Console.WriteLine("After Delete ");
task.deleteNode(m, n);
task.display();
}
}
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
<?php
// Php Program
// Delete N nodes of after the M nodes set B
class Node
{
public $data;
public $next;
public function __construct($value)
{
$this->data = $value;
$this->next = NULL;
}
}
class LinkedList
{
public $head;
// Class constructors
public function __construct()
{
$this->head = NULL;
}
// Insert new node at the last
public function insert($value)
{
// Create new node
$node = new Node($value);
if ($this->head == NULL)
{
$this->head = $node;
}
else
{
$temp = $this->head;
// find last node
while ($temp->next != NULL)
{
// visit to next node
$temp = $temp->next;
}
// add node
$temp->next = $node;
}
}
// Display all Linked List elements
public function display()
{
if ($this->head != NULL)
{
printf("%s", "Linked List Element :");
$temp = $this->head;
while ($temp != NULL)
{
printf("%s", " ".strval($temp->data));
$temp = $temp->next;
}
}
else
{
printf("%s\n", "Empty Linked list");
}
}
public function deleteNode($m, $n)
{
if ($this->head == NULL)
{
printf("%s\n", "Empty Linked List");
}
else if ($m <= 0 || $n <= 0)
{
printf("%s\n", "Invalid position");
}
else
{
$count = 0;
$find = 0;
$temp = $this->head;
$hold = NULL;
$current = NULL;
while ($temp != NULL)
{
if ($find < $m)
{
//When need to skip element
$find++;
$hold = $temp;
$temp = $temp->next;
if ($find == $m - 1 && $temp != NULL)
{
$current = $temp->next;
$find = 0;
// Check it out new deleted sequence are exist or not
while ($current != NULL)
{
$find++;
$current = $current->next;
if ($find == $n)
{
break;
}
}
if ($find != $n)
{
// When group of N nodes are not exist
// break the execution process
break;
}
else
{
$find = $m - 1;
}
}
}
else
{
$temp = $temp->next;
// Location is to find delete node
if ($hold->next != NULL)
{
// When delete node is found
$current = $hold->next;
$hold->next = $current->next;
$current = NULL;
}
$count++;
if ($count == $n)
{
//reset the value
$count = 0;
$find = 0;
}
}
}
}
}
public static
function main($args)
{
$m = 2;
$n = 3;
$task = new LinkedList();
$task->insert(1);
$task->insert(2);
$task->insert(3);
$task->insert(4);
$task->insert(5);
$task->insert(6);
$task->insert(7);
$task->insert(8);
$task->insert(9);
printf("%s\n", "\nBefore Delete ");
$task->display();
printf("%s\n", "\n M: ".strval($m).
" N: ".strval($n).
" ");
printf("%s\n", "After Delete ");
$task->deleteNode($m, $n);
$task->display();
}
}
LinkedList::main(array());
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
// Node JS Program
// Delete N nodes of after the M nodes set B
class Node
{
constructor(value)
{
this.data = value;
this.next = null;
}
}
class LinkedList
{
// Class constructors
constructor()
{
this.head = null;
}
// Insert new node at the last
insert(value)
{
// Create new node
var node = new Node(value);
if (this.head == null)
{
this.head = node;
}
else
{
var temp = this.head;
// find last node
while (temp.next != null)
{
// visit to next node
temp = temp.next;
}
// add node
temp.next = node;
}
}
// Display all Linked List elements
display()
{
if (this.head != null)
{
process.stdout.write("Linked List Element :");
var temp = this.head;
while (temp != null)
{
process.stdout.write(" " + temp.data);
temp = temp.next;
}
}
else
{
console.log("Empty Linked list");
}
}
deleteNode(m, n)
{
if (this.head == null)
{
console.log("Empty Linked List");
}
else if (m <= 0 || n <= 0)
{
console.log("Invalid position");
}
else
{
var count = 0;
var find = 0;
var temp = this.head;
var hold = null;
var current = null;
while (temp != null)
{
if (find < m)
{
//When need to skip element
find++;
hold = temp;
temp = temp.next;
if (find == m - 1 && temp != null)
{
current = temp.next;
find = 0;
// Check it out new deleted sequence are exist or not
while (current != null)
{
find++;
current = current.next;
if (find == n)
{
break;
}
}
if (find != n)
{
// When group of N nodes are not exist
// break the execution process
break;
}
else
{
find = m - 1;
}
}
}
else
{
temp = temp.next;
// Location is to find delete node
if (hold.next != null)
{
// When delete node is found
current = hold.next;
hold.next = current.next;
current = null;
}
count++;
if (count == n)
{
//reset the value
count = 0;
find = 0;
}
}
}
}
}
}
function main()
{
var m = 2;
var n = 3;
var task = new LinkedList();
task.insert(1);
task.insert(2);
task.insert(3);
task.insert(4);
task.insert(5);
task.insert(6);
task.insert(7);
task.insert(8);
task.insert(9);
console.log("\nBefore Delete ");
task.display();
console.log("\n M: " + m + " N: " + n + " ");
console.log("After Delete ");
task.deleteNode(m, n);
task.display();
}
// Start program execution
main();
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
# Python 3 Program
# Delete N nodes of after the M nodes set B
class Node :
def __init__(self, value) :
self.data = value
self.next = None
class LinkedList :
# Class constructors
def __init__(self) :
self.head = None
# Insert new node at the last
def insert(self, value) :
# Create new node
node = Node(value)
if (self.head == None) :
self.head = node
else :
temp = self.head
# find last node
while (temp.next != None) :
# visit to next node
temp = temp.next
# add node
temp.next = node
# Display all Linked List elements
def display(self) :
if (self.head != None) :
print("Linked List Element :", end = "")
temp = self.head
while (temp != None) :
print(" ", temp.data, end = " ")
temp = temp.next
else :
print("Empty Linked list")
def deleteNode(self, m, n) :
if (self.head == None) :
print("Empty Linked List")
elif (m <= 0 or n <= 0) :
print("Invalid position")
else :
count = 0
find = 0
temp = self.head
hold = None
current = None
while (temp != None) :
if (find < m) :
# When need to skip element
find += 1
hold = temp
temp = temp.next
if (find == m - 1 and temp != None) :
current = temp.next
find = 0
# Check it out new deleted sequence are exist or not
while (current != None) :
find += 1
current = current.next
if (find == n) :
break
if (find != n) :
# When group of N nodes are not exist
# break the execution process
break
else :
find = m - 1
else :
temp = temp.next
# Location is to find delete node
if (hold.next != None) :
# When delete node is found
current = hold.next
hold.next = current.next
current = None
count += 1
if (count == n) :
# reset the value
count = 0
find = 0
def main() :
m = 2
n = 3
task = LinkedList()
task.insert(1)
task.insert(2)
task.insert(3)
task.insert(4)
task.insert(5)
task.insert(6)
task.insert(7)
task.insert(8)
task.insert(9)
print("\nBefore Delete ")
task.display()
print("\n M: ", m ," N: ", n ," ")
print("After Delete ")
task.deleteNode(m, n)
task.display()
if __name__ == "__main__": main()
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
# Ruby Program
# Delete N nodes of after the M nodes set B
class Node
# Define the accessor and reader of class Node
attr_reader :data, :next
attr_accessor :data, :next
def initialize(value)
self.data = value
self.next = nil
end
end
class LinkedList
# Define the accessor and reader of class LinkedList
attr_reader :head
attr_accessor :head
# Class constructors
def initialize()
self.head = nil
end
# Insert new node at the last
def insert(value)
# Create new node
node = Node.new(value)
if (self.head == nil)
self.head = node
else
temp = self.head
# find last node
while (temp.next != nil)
# visit to next node
temp = temp.next
end
# add node
temp.next = node
end
end
# Display all Linked List elements
def display()
if (self.head != nil)
print("Linked List Element :")
temp = self.head
while (temp != nil)
print(" ", temp.data)
temp = temp.next
end
else
print("Empty Linked list", "\n")
end
end
def deleteNode(m, n)
if (self.head == nil)
print("Empty Linked List", "\n")
elsif (m <= 0 || n <= 0)
print("Invalid position", "\n")
else
count = 0
find = 0
temp = self.head
hold = nil
current = nil
while (temp != nil)
if (find < m)
# When need to skip element
find += 1
hold = temp
temp = temp.next
if (find == m - 1 && temp != nil)
current = temp.next
find = 0
# Check it out new deleted sequence are exist or not
while (current != nil)
find += 1
current = current.next
if (find == n)
break
end
end
if (find != n)
# When group of N nodes are not exist
# break the execution process
break
else
find = m - 1
end
end
else
temp = temp.next
# Location is to find delete node
if (hold.next != nil)
# When delete node is found
current = hold.next
hold.next = current.next
current = nil
end
count += 1
if (count == n)
# reset the value
count = 0
find = 0
end
end
end
end
end
end
def main()
m = 2
n = 3
task = LinkedList.new()
task.insert(1)
task.insert(2)
task.insert(3)
task.insert(4)
task.insert(5)
task.insert(6)
task.insert(7)
task.insert(8)
task.insert(9)
print("\nBefore Delete ", "\n")
task.display()
print("\n M: ", m ," N: ", n ," ", "\n")
print("After Delete ", "\n")
task.deleteNode(m, n)
task.display()
end
main()
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
// Scala Program
// Delete N nodes of after the M nodes set B
class Node(var data: Int,
var next: Node)
{
def this(value: Int)
{
this(value, null);
}
}
class LinkedList(var head: Node)
{
// Class constructors
def this()
{
this(null);
}
// Insert new node at the last
def insert(value: Int): Unit = {
// Create new node
var node: Node = new Node(value);
if (head == null)
{
head = node;
}
else
{
var temp: Node = head;
// find last node
while (temp.next != null)
{
// visit to next node
temp = temp.next;
}
// add node
temp.next = node;
}
}
// Display all Linked List elements
def display(): Unit = {
if (this.head != null)
{
print("Linked List Element :");
var temp: Node = head;
while (temp != null)
{
print(" " + temp.data);
temp = temp.next;
}
}
else
{
println("Empty Linked list");
}
}
def deleteNode(m: Int, n: Int): Unit = {
if (this.head == null)
{
println("Empty Linked List");
}
else if (m <= 0 || n <= 0)
{
println("Invalid position");
}
else
{
var count: Int = 0;
var find: Int = 0;
var temp: Node = this.head;
var hold: Node = null;
var current: Node = null;
while (temp != null)
{
if (find < m)
{
//When need to skip element
find += 1;
hold = temp;
temp = temp.next;
if (find == m - 1 && temp != null)
{
current = temp.next;
find = 0;
// Check it out new deleted sequence are exist or not
while (current != null && find < n)
{
find += 1;
current = current.next;
}
if (find != n)
{
// When group of N nodes are not exist
// break the execution process
return;
}
else
{
find = m - 1;
}
}
}
else
{
temp = temp.next;
// Location is to find delete node
if (hold.next != null)
{
// When delete node is found
current = hold.next;
hold.next = current.next;
current = null;
}
count += 1;
if (count == n)
{
//reset the value
count = 0;
find = 0;
}
}
}
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var m: Int = 2;
var n: Int = 3;
var task: LinkedList = new LinkedList();
task.insert(1);
task.insert(2);
task.insert(3);
task.insert(4);
task.insert(5);
task.insert(6);
task.insert(7);
task.insert(8);
task.insert(9);
println("\nBefore Delete ");
task.display();
println("\n M: " + m + " N: " + n + " ");
println("After Delete ");
task.deleteNode(m, n);
task.display();
}
}
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
import Foundation
// Java Program
// Delete N nodes of after the M nodes set B
class Node
{
var data: Int;
var next: Node? ;
init(_ value: Int)
{
self.data = value;
self.next = nil;
}
}
class LinkedList
{
var head: Node? ;
// Class constructors
init()
{
self.head = nil;
}
// Insert new node at the last
func insert(_ value: Int)
{
// Create new node
let node: Node? = Node(value);
if (self.head == nil)
{
self.head = node;
}
else
{
var temp: Node? = self.head;
// find last node
while (temp!.next != nil)
{
// visit to next node
temp = temp!.next;
}
// add node
temp!.next = node;
}
}
// Display all Linked List elements
func display()
{
if (self.head != nil)
{
print("Linked List Element :", terminator: "");
var temp: Node? = self.head;
while (temp != nil)
{
print(" "
+ String(temp!.data), terminator: "");
temp = temp!.next;
}
}
else
{
print("Empty Linked list");
}
}
func deleteNode(_ m: Int, _ n: Int)
{
if (self.head == nil)
{
print("Empty Linked List");
}
else if (m <= 0 || n <= 0)
{
print("Invalid position");
}
else
{
var count: Int = 0;
var find: Int = 0;
var temp: Node? = self.head;
var hold: Node? = nil;
var current: Node? = nil;
while (temp != nil)
{
if (find < m)
{
//When need to skip element
find += 1;
hold = temp;
temp = temp!.next;
if (find == m - 1 && temp != nil)
{
current = temp!.next;
find = 0;
// Check it out new deleted sequence are exist or not
while (current != nil)
{
find += 1;
current = current!.next;
if (find == n)
{
break;
}
}
if (find != n)
{
// When group of N nodes are not exist
// break the execution process
break;
}
else
{
find = m - 1;
}
}
}
else
{
temp = temp!.next;
// Location is to find delete node
if (hold!.next != nil)
{
// When delete node is found
current = hold!.next;
hold!.next = current!.next;
current = nil;
}
count += 1;
if (count == n)
{
//reset the value
count = 0;
find = 0;
}
}
}
}
}
static func main(_ args: [String])
{
let m: Int = 2;
let n: Int = 3;
let task: LinkedList? = LinkedList();
task!.insert(1);
task!.insert(2);
task!.insert(3);
task!.insert(4);
task!.insert(5);
task!.insert(6);
task!.insert(7);
task!.insert(8);
task!.insert(9);
print("\nBefore Delete ");
task!.display();
print("\n M: "
+ String(m) + " N: "
+ String(n) + " ");
print("After Delete ");
task!.deleteNode(m, n);
task!.display();
}
}
LinkedList.main([String]());
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
// Kotlin Program
// Delete N nodes of after the M nodes set B
class Node
{
var data: Int;
var next: Node ? ;
constructor(value: Int)
{
this.data = value;
this.next = null;
}
}
class LinkedList
{
var head: Node ? ;
// Class constructors
constructor()
{
this.head = null;
}
// Insert new node at the last
fun insert(value: Int): Unit
{
// Create new node
val node: Node = Node(value);
if (this.head == null)
{
this.head = node;
}
else
{
var temp: Node ? = this.head;
// find last node
while (temp?.next != null)
{
// visit to next node
temp = temp.next;
}
// add node
temp?.next = node;
}
}
// Display all Linked List elements
fun display(): Unit
{
if (this.head != null)
{
print("Linked List Element :");
var temp: Node ? = this.head;
while (temp != null)
{
print(" " + temp.data);
temp = temp.next;
}
}
else
{
println("Empty Linked list");
}
}
fun deleteNode(m: Int, n: Int): Unit
{
if (this.head == null)
{
println("Empty Linked List");
}
else if (m <= 0 || n <= 0)
{
println("Invalid position");
}
else
{
var count: Int = 0;
var find: Int = 0;
var temp: Node ? = this.head;
var hold: Node ? = null;
var current: Node ? ;
while (temp != null)
{
if (find < m)
{
//When need to skip element
find += 1;
hold = temp;
temp = temp.next;
if (find == m - 1 && temp != null)
{
current = temp.next;
find = 0;
// Check it out new deleted sequence are exist or not
while (current != null)
{
find += 1;
current = current.next;
if (find == n)
{
break;
}
}
if (find != n)
{
// When group of N nodes are not exist
// break the execution process
break;
}
else
{
find = m - 1;
}
}
}
else
{
temp = temp.next;
// Location is to find delete node
if (hold?.next != null)
{
// When delete node is found
current = hold.next;
hold.next = current?.next;
}
count += 1;
if (count == n)
{
//reset the value
count = 0;
find = 0;
}
}
}
}
}
}
fun main(args: Array < String > ): Unit
{
val m: Int = 2;
val n: Int = 3;
val task: LinkedList = LinkedList();
task.insert(1);
task.insert(2);
task.insert(3);
task.insert(4);
task.insert(5);
task.insert(6);
task.insert(7);
task.insert(8);
task.insert(9);
println("\nBefore Delete ");
task.display();
println("\n M: " + m + " N: " + n + " ");
println("After Delete ");
task.deleteNode(m, n);
task.display();
}
Output
Before Delete
Linked List Element : 1 2 3 4 5 6 7 8 9
M: 2 N: 3
After Delete
Linked List Element : 1 2 6 7 8 9
Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.
New Comment