Delete middle element of a stack
Here given code implementation process.
// C program
// Delete middle element of a stack
#include <stdio.h>
#include <stdlib.h>
// Define stack node
struct StackNode
{
int element;
struct StackNode *next;
};
// Define a custom stack
struct MyStack
{
struct StackNode *top;
int size;
};
struct MyStack *newStack()
{
//Make a stack
struct MyStack *stack = (struct MyStack *) malloc(sizeof(struct MyStack));
if (stack != NULL)
{
//Set node values
stack->top = NULL;
stack->size = 0;
}
else
{
printf("\nMemory overflow when create new stack\n");
}
}
//Create a new node of stack
struct StackNode *newNode(int element, struct StackNode *next)
{
//Make a new node
struct StackNode *node = (struct StackNode *) malloc(sizeof(struct StackNode));
if (node == NULL)
{
printf("\nMemory overflow when create new stack Node \n");
}
else
{
node->element = element;
node->next = next;
}
return node;
}
// Returns the status of empty or non empty stacks
int isEmpty(struct MyStack *stack)
{
if (stack->size > 0 && stack->top != NULL)
{
return 0;
}
else
{
return 1;
}
}
// Add node at the top of stack
void push(struct MyStack *stack, int element)
{
// Add stack element
stack->top = newNode(element, stack->top);
stack->size++;
}
// return top element of stack
int peek(struct MyStack *stack)
{
return stack->top->element;
}
// Remove top element of stack
void pop(struct MyStack *stack)
{
if (isEmpty(stack) == 0)
{
struct StackNode *temp = stack->top;
// Change top element of stack
stack->top = temp->next;
// remove previous top
free(temp);
temp = NULL;
stack->size--;
}
}
// Remove middle element of stack
void removeMiddle(struct MyStack *stack, int mid, int counter)
{
if (counter == mid)
{
printf("\n Delete middle element : %d", peek(stack));
// Delete middle node
pop(stack);
}
else if (counter < mid && isEmpty(stack) == 0)
{
// When stack not empty and counter is less than middle position
// Get top element
int element = peek(stack);
// Remove top element
pop(stack);
// Recursively finding the middle element
removeMiddle(stack, mid, counter + 1);
// Add element in stack
push(stack, element);
}
}
// Handles the request to delete middle element of stack
void deleteMiddle(struct MyStack *stack)
{
if (isEmpty(stack) == 0)
{
// Get middle element location
int mid = stack->size / 2;
removeMiddle(stack, mid, 0);
}
else
{
printf("\n Stack Is Empty \n");
}
}
// Print element of stack
void printData(struct MyStack *stack)
{
struct StackNode *temp = stack->top;
// iterate stack elements
while (temp != NULL)
{
// Display element value
printf(" %d", temp->element);
temp = temp->next;
}
printf("\n");
}
int main()
{
struct MyStack *stack = newStack();
// Add the stack element
push(stack, 7);
push(stack, 6);
push(stack, 5);
push(stack, 4);
push(stack, 3);
push(stack, 2);
push(stack, 1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
printf("\n Stack element \n");
printData(stack);
// delete operation
deleteMiddle(stack);
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
printf("\n After Delete stack \n");
printData(stack);
// delete operation
deleteMiddle(stack);
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
printf("\n After Delete stack \n");
printData(stack);
// delete operation
deleteMiddle(stack);
/*
After delete middle element
============
1 <- Top
2
6
7
*/
printf("\n After Delete stack \n");
printData(stack);
return 0;
}
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
/*
Java Program
Delete middle element of a stack
*/
// Define stack node
class StackNode
{
public int element;
public StackNode next;
public StackNode(int element, StackNode next)
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
class MyStack
{
public StackNode top;
public int size;
public MyStack()
{
//Set node values
this.top = null;
this.size = 0;
}
// Add node at the top of stack
public void push(int element)
{
this.top = new StackNode(element, this.top);
this.size++;
}
public Boolean isEmpty()
{
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
public void pop()
{
if (this.size > 0 && this.top != null)
{
StackNode temp = this.top;
// Change top element of stack
this.top = temp.next;
// remove previous top
temp = null;
this.size--;
}
}
// return top element of stack
public int peek()
{
return this.top.element;
}
}
public class DeleteElement
{
public MyStack stack;
public DeleteElement()
{
this.stack = new MyStack();
}
// Print element of stack
public void printData()
{
StackNode temp = this.stack.top;
while (temp != null)
{
// Display element value
System.out.print(" " + temp.element);
temp = temp.next;
}
System.out.print("\n");
}
// Remove middle element of stack
public void removeMiddle(int mid, int counter)
{
if (counter == mid)
{
// When get middle element
System.out.print("\n Delete middle element : " + this.stack.peek() + "");
// Delete middle node
this.stack.pop();
}
else if (counter < mid && this.stack.isEmpty() == false)
{
// When stack not empty and counter is less than middle position
// Get top element
int element = this.stack.peek();
// Remove top element
this.stack.pop();
// Recursively finding the middle element
removeMiddle(mid, counter + 1);
// Add element in stack
this.stack.push(element);
}
}
// Handles the request to delete middle element of stack
public void deleteMiddle()
{
if (this.stack.isEmpty() == false)
{
// Get middle element location
int mid = this.stack.size / 2;
removeMiddle(mid, 0);
}
else
{
System.out.print("\n Stack Is Empty \n");
}
}
public static void main(String[] args)
{
DeleteElement task = new DeleteElement();
// Add stack element
task.stack.push(7);
task.stack.push(6);
task.stack.push(5);
task.stack.push(4);
task.stack.push(3);
task.stack.push(2);
task.stack.push(1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
System.out.print("\n Stack element \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
System.out.print("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
System.out.print("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
6
7
*/
System.out.print("\n After Delete stack \n");
task.printData();
}
}
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
// Include header file
#include <iostream>
using namespace std;
/*
C++ Program
Delete middle element of a stack
*/
// Define stack node
class StackNode
{
public: int element;
StackNode *next;
StackNode(int element, StackNode *next)
{
this->element = element;
this->next = next;
}
};
// Define a custom stack
class MyStack
{
public: StackNode *top;
int size;
MyStack()
{
//Set node values
this->top = NULL;
this->size = 0;
}
// Add node at the top of stack
void push(int element)
{
this->top = new StackNode(element, this->top);
this->size++;
}
bool isEmpty()
{
if (this->size > 0 && this->top != NULL)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
void pop()
{
if (this->size > 0 && this->top != NULL)
{
StackNode *temp = this->top;
// Change top element of stack
this->top = temp->next;
// remove previous top
temp = NULL;
this->size--;
}
}
// return top element of stack
int peek()
{
return this->top->element;
}
};
class DeleteElement
{
public:
MyStack stack;
DeleteElement()
{
this->stack = MyStack();
}
// Print element of stack
void printData()
{
StackNode *temp = this->stack.top;
while (temp != NULL)
{
// Display element value
cout << " " << temp->element;
temp = temp->next;
}
cout << "\n";
}
// Remove middle element of stack
void removeMiddle(int mid, int counter)
{
if (counter == mid)
{
// When get middle element
cout << "\n Delete middle element : " << this->stack.peek() << "";
// Delete middle node
this->stack.pop();
}
else if (counter < mid && this->stack.isEmpty() == false)
{
// When stack not empty and counter is less than middle position
// Get top element
int element = this->stack.peek();
// Remove top element
this->stack.pop();
// Recursively finding the middle element
this->removeMiddle(mid, counter + 1);
// Add element in stack
this->stack.push(element);
}
}
// Handles the request to delete middle element of stack
void deleteMiddle()
{
if (this->stack.isEmpty() == false)
{
// Get middle element location
int mid = this->stack.size / 2;
this->removeMiddle(mid, 0);
}
else
{
cout << "\n Stack Is Empty \n";
}
}
};
int main()
{
DeleteElement task = DeleteElement();
// Add stack element
task.stack.push(7);
task.stack.push(6);
task.stack.push(5);
task.stack.push(4);
task.stack.push(3);
task.stack.push(2);
task.stack.push(1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
cout << "\n Stack element \n";
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
cout << "\n After Delete stack \n";
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
cout << "\n After Delete stack \n";
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
6
7
*/
cout << "\n After Delete stack \n";
task.printData();
return 0;
}
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
// Include namespace system
using System;
/*
C# Program
Delete middle element of a stack
*/
// Define stack node
public class StackNode
{
public int element;
public StackNode next;
public StackNode(int element, StackNode next)
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
public class MyStack
{
public StackNode top;
public int size;
public MyStack()
{
//Set node values
this.top = null;
this.size = 0;
}
// Add node at the top of stack
public void push(int element)
{
this.top = new StackNode(element, this.top);
this.size++;
}
public Boolean isEmpty()
{
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
public void pop()
{
if (this.size > 0 && this.top != null)
{
StackNode temp = this.top;
// Change top element of stack
this.top = temp.next;
// remove previous top
temp = null;
this.size--;
}
}
// return top element of stack
public int peek()
{
return this.top.element;
}
}
public class DeleteElement
{
public MyStack stack;
public DeleteElement()
{
this.stack = new MyStack();
}
// Print element of stack
public void printData()
{
StackNode temp = this.stack.top;
while (temp != null)
{
// Display element value
Console.Write(" " + temp.element);
temp = temp.next;
}
Console.Write("\n");
}
// Remove middle element of stack
public void removeMiddle(int mid, int counter)
{
if (counter == mid)
{
// When get middle element
Console.Write("\n Delete middle element : " + this.stack.peek() + "");
// Delete middle node
this.stack.pop();
}
else if (counter < mid && this.stack.isEmpty() == false)
{
// When stack not empty and counter is less than middle position
// Get top element
int element = this.stack.peek();
// Remove top element
this.stack.pop();
// Recursively finding the middle element
removeMiddle(mid, counter + 1);
// Add element in stack
this.stack.push(element);
}
}
// Handles the request to delete middle element of stack
public void deleteMiddle()
{
if (this.stack.isEmpty() == false)
{
// Get middle element location
int mid = this.stack.size / 2;
removeMiddle(mid, 0);
}
else
{
Console.Write("\n Stack Is Empty \n");
}
}
public static void Main(String[] args)
{
DeleteElement task = new DeleteElement();
// Add stack element
task.stack.push(7);
task.stack.push(6);
task.stack.push(5);
task.stack.push(4);
task.stack.push(3);
task.stack.push(2);
task.stack.push(1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
Console.Write("\n Stack element \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
Console.Write("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
Console.Write("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
6
7
*/
Console.Write("\n After Delete stack \n");
task.printData();
}
}
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
<?php
/*
Php Program
Delete middle element of a stack
*/
// Define stack node
class StackNode
{
public $element;
public $next;
function __construct($element, $next)
{
$this->element = $element;
$this->next = $next;
}
}
// Define a custom stack
class MyStack
{
public $top;
public $size;
function __construct()
{
//Set node values
$this->top = null;
$this->size = 0;
}
// Add node at the top of stack
public function push($element)
{
$this->top = new StackNode($element, $this->top);
$this->size++;
}
public function isEmpty()
{
if ($this->size > 0 && $this->top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
public function pop()
{
if ($this->size > 0 && $this->top != null)
{
$temp = $this->top;
// Change top element of stack
$this->top = $temp->next;
// remove previous top
$temp = null;
$this->size--;
}
}
// return top element of stack
public function peek()
{
return $this->top->element;
}
}
class DeleteElement
{
public $stack;
function __construct()
{
$this->stack = new MyStack();
}
// Print element of stack
public function printData()
{
$temp = $this->stack->top;
while ($temp != null)
{
// Display element value
echo " ". $temp->element;
$temp = $temp->next;
}
echo "\n";
}
// Remove middle element of stack
public function removeMiddle($mid, $counter)
{
if ($counter == $mid)
{
// When get middle element
echo "\n Delete middle element : ". $this->stack->peek() ."";
// Delete middle node
$this->stack->pop();
}
else if ($counter < $mid && $this->stack->isEmpty() == false)
{
// When stack not empty and counter is less than middle position
// Get top element
$element = $this->stack->peek();
// Remove top element
$this->stack->pop();
// Recursively finding the middle element
$this->removeMiddle($mid, $counter + 1);
// Add element in stack
$this->stack->push($element);
}
}
// Handles the request to delete middle element of stack
public function deleteMiddle()
{
if ($this->stack->isEmpty() == false)
{
// Get middle element location
$mid = intval($this->stack->size / 2);
$this->removeMiddle($mid, 0);
}
else
{
echo "\n Stack Is Empty \n";
}
}
}
function main()
{
$task = new DeleteElement();
// Add stack element
$task->stack->push(7);
$task->stack->push(6);
$task->stack->push(5);
$task->stack->push(4);
$task->stack->push(3);
$task->stack->push(2);
$task->stack->push(1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
echo "\n Stack element \n";
$task->printData();
// delete operation
$task->deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
echo "\n After Delete stack \n";
$task->printData();
// delete operation
$task->deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
echo "\n After Delete stack \n";
$task->printData();
// delete operation
$task->deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
6
7
*/
echo "\n After Delete stack \n";
$task->printData();
}
main();
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
/*
Node Js Program
Delete middle element of a stack
*/
// Define stack node
class StackNode
{
constructor(element, next)
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
class MyStack
{
constructor()
{
//Set node values
this.top = null;
this.size = 0;
}
// Add node at the top of stack
push(element)
{
this.top = new StackNode(element, this.top);
this.size++;
}
isEmpty()
{
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
pop()
{
if (this.size > 0 && this.top != null)
{
var temp = this.top;
// Change top element of stack
this.top = temp.next;
// remove previous top
temp = null;
this.size--;
}
}
// return top element of stack
peek()
{
return this.top.element;
}
}
class DeleteElement
{
constructor()
{
this.stack = new MyStack();
}
// Print element of stack
printData()
{
var temp = this.stack.top;
while (temp != null)
{
// Display element value
process.stdout.write(" " + temp.element);
temp = temp.next;
}
process.stdout.write("\n");
}
// Remove middle element of stack
removeMiddle(mid, counter)
{
if (counter == mid)
{
// When get middle element
process.stdout.write("\n Delete middle element : " + this.stack.peek() + "");
// Delete middle node
this.stack.pop();
}
else if (counter < mid && this.stack.isEmpty() == false)
{
// When stack not empty and counter is less than middle position
// Get top element
var element = this.stack.peek();
// Remove top element
this.stack.pop();
// Recursively finding the middle element
this.removeMiddle(mid, counter + 1);
// Add element in stack
this.stack.push(element);
}
}
// Handles the request to delete middle element of stack
deleteMiddle()
{
if (this.stack.isEmpty() == false)
{
// Get middle element location
var mid = parseInt(this.stack.size / 2);
this.removeMiddle(mid, 0);
}
else
{
process.stdout.write("\n Stack Is Empty \n");
}
}
}
function main()
{
var task = new DeleteElement();
// Add stack element
task.stack.push(7);
task.stack.push(6);
task.stack.push(5);
task.stack.push(4);
task.stack.push(3);
task.stack.push(2);
task.stack.push(1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
process.stdout.write("\n Stack element \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
process.stdout.write("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
process.stdout.write("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
6
7
*/
process.stdout.write("\n After Delete stack \n");
task.printData();
}
main();
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
# Python 3 Program
# Delete middle element of a stack
# Define stack node
class StackNode :
def __init__(self, element, next) :
self.element = element
self.next = next
# Define a custom stack
class MyStack :
def __init__(self) :
# Set node values
self.top = None
self.size = 0
# Add node at the top of stack
def push(self, element) :
self.top = StackNode(element, self.top)
self.size += 1
def isEmpty(self) :
if (self.size > 0 and self.top != None) :
return False
else :
return True
# Remove top element of stack
def pop(self) :
if (self.size > 0 and self.top != None) :
temp = self.top
# Change top element of stack
self.top = temp.next
# remove previous top
temp = None
self.size -= 1
# return top element of stack
def peek(self) :
return self.top.element
class DeleteElement :
def __init__(self) :
self.stack = MyStack()
# Print element of stack
def printData(self) :
temp = self.stack.top
while (temp != None) :
# Display element value
print(" ", temp.element, end = "")
temp = temp.next
print(end = "\n")
# Remove middle element of stack
def removeMiddle(self, mid, counter) :
if (counter == mid) :
# When get middle element
print("\n Delete middle element : ", self.stack.peek() ,"", end = "")
# Delete middle node
self.stack.pop()
elif(counter < mid and self.stack.isEmpty() == False) :
# When stack not empty and counter is less than middle position
# Get top element
element = self.stack.peek()
# Remove top element
self.stack.pop()
# Recursively finding the middle element
self.removeMiddle(mid, counter + 1)
# Add element in stack
self.stack.push(element)
# Handles the request to delete middle element of stack
def deleteMiddle(self) :
if (self.stack.isEmpty() == False) :
# Get middle element location
mid = int(self.stack.size / 2)
self.removeMiddle(mid, 0)
else :
print("\n Stack Is Empty ")
def main() :
task = DeleteElement()
task.stack.push(7)
task.stack.push(6)
task.stack.push(5)
task.stack.push(4)
task.stack.push(3)
task.stack.push(2)
task.stack.push(1)
#
# Created Stack
# ============
# 1 <- Top
# 2
# 3
# 4
# 5
# 6
# 7
#
print("\n Stack element ")
task.printData()
# delete operation
task.deleteMiddle()
#
# After delete middle element
# ============
# 1 <- Top
# 2
# 3
# 5
# 6
# 7
#
print("\n After Delete stack ")
task.printData()
# delete operation
task.deleteMiddle()
#
# After delete middle element
# ============
# 1 <- Top
# 2
# 3
# 6
# 7
#
print("\n After Delete stack ")
task.printData()
# delete operation
task.deleteMiddle()
#
# After delete middle element
# ============
# 1 <- Top
# 2
# 6
# 7
#
print("\n After Delete stack ")
task.printData()
if __name__ == "__main__": main()
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
# Ruby Program
# Delete middle element of a stack
# Define stack node
class StackNode
# Define the accessor and reader of class StackNode
attr_reader :element, :next
attr_accessor :element, :next
def initialize(element, nextNode)
self.element = element
self.next = nextNode
end
end
# Define a custom stack
class MyStack
# Define the accessor and reader of class MyStack
attr_reader :top, :size
attr_accessor :top, :size
def initialize()
# Set node values
self.top = nil
self.size = 0
end
# Add node at the top of stack
def push(element)
self.top = StackNode.new(element, self.top)
self.size += 1
end
def isEmpty()
if (self.size > 0 && self.top != nil)
return false
else
return true
end
end
# Remove top element of stack
def pop()
if (self.size > 0 && self.top != nil)
temp = self.top
# Change top element of stack
self.top = temp.next
# remove previous top
temp = nil
self.size -= 1
end
end
# return top element of stack
def peek()
return self.top.element
end
end
class DeleteElement
# Define the accessor and reader of class DeleteElement
attr_reader :stack
attr_accessor :stack
def initialize()
self.stack = MyStack.new()
end
# Print element of stack
def printData()
temp = self.stack.top
while (temp != nil)
# Display element value
print(" ", temp.element)
temp = temp.next
end
print("\n")
end
# Remove middle element of stack
def removeMiddle(mid, counter)
if (counter == mid)
# When get middle element
print("\n Delete middle element : ", self.stack.peek() ,"")
# Delete middle node
self.stack.pop()
elsif(counter < mid && self.stack.isEmpty() == false)
# When stack not empty and counter is less than middle position
# Get top element
element = self.stack.peek()
# Remove top element
self.stack.pop()
# Recursively finding the middle element
self.removeMiddle(mid, counter + 1)
# Add element in stack
self.stack.push(element)
end
end
# Handles the request to delete middle element of stack
def deleteMiddle()
if (self.stack.isEmpty() == false)
# Get middle element location
mid = self.stack.size / 2
self.removeMiddle(mid, 0)
else
print("\n Stack Is Empty \n")
end
end
end
def main()
task = DeleteElement.new()
task.stack.push(7)
task.stack.push(6)
task.stack.push(5)
task.stack.push(4)
task.stack.push(3)
task.stack.push(2)
task.stack.push(1)
#
# Created Stack
# ============
# 1 <- Top
# 2
# 3
# 4
# 5
# 6
# 7
#
print("\n Stack element \n")
task.printData()
# delete operation
task.deleteMiddle()
#
# After delete middle element
# ============
# 1 <- Top
# 2
# 3
# 5
# 6
# 7
#
print("\n After Delete stack \n")
task.printData()
# delete operation
task.deleteMiddle()
#
# After delete middle element
# ============
# 1 <- Top
# 2
# 3
# 6
# 7
#
print("\n After Delete stack \n")
task.printData()
# delete operation
task.deleteMiddle()
#
# After delete middle element
# ============
# 1 <- Top
# 2
# 6
# 7
#
print("\n After Delete stack \n")
task.printData()
end
main()
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
/*
Scala Program
Delete middle element of a stack
*/
// Define stack node
class StackNode(var element: Int , var next: StackNode)
{
}
// Define a custom stack
class MyStack(var top: StackNode , var size: Int)
{
def this()
{
this(null, 0);
}
// Add node at the top of stack
def push(element: Int): Unit = {
this.top = new StackNode(element, this.top);
this.size += 1;
}
def isEmpty(): Boolean = {
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
def pop(): Unit = {
if (this.size > 0 && this.top != null)
{
var temp: StackNode = this.top;
// Change top element of stack
this.top = temp.next;
// remove previous top
temp = null;
this.size -= 1;
}
}
// return top element of stack
def peek(): Int = {
return this.top.element;
}
}
class DeleteElement(var stack: MyStack)
{
def this()
{
this(new MyStack());
}
// Print element of stack
def printData(): Unit = {
var temp: StackNode = this.stack.top;
while (temp != null)
{
// Display element value
print(" " + temp.element);
temp = temp.next;
}
print("\n");
}
// Remove middle element of stack
def removeMiddle(mid: Int, counter: Int): Unit = {
if (counter == mid)
{
// When get middle element
print("\n Delete middle element : " + this.stack.peek() );
// Delete middle node
this.stack.pop();
}
else if (counter < mid && this.stack.isEmpty() == false)
{
// When stack not empty and counter is less than middle position
// Get top element
var element: Int = this.stack.peek();
// Remove top element
this.stack.pop();
// Recursively finding the middle element
this.removeMiddle(mid, counter + 1);
// Add element in stack
this.stack.push(element);
}
}
// Handles the request to delete middle element of stack
def deleteMiddle(): Unit = {
if (this.stack.isEmpty() == false)
{
// Get middle element location
var mid: Int = (this.stack.size / 2).toInt;
this.removeMiddle(mid, 0);
}
else
{
print("\n Stack Is Empty \n");
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: DeleteElement = new DeleteElement();
// Add stack element
task.stack.push(7);
task.stack.push(6);
task.stack.push(5);
task.stack.push(4);
task.stack.push(3);
task.stack.push(2);
task.stack.push(1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
print("\n Stack element \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
print("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
print("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
6
7
*/
print("\n After Delete stack \n");
task.printData();
}
}
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
/*
Swift 4 Program
Delete middle element of a stack
*/
// Define stack node
class StackNode
{
var element: Int;
var next: StackNode? ;
init(_ element: Int, _ next: StackNode? )
{
self.element = element;
self.next = next;
}
}
// Define a custom stack
class MyStack
{
var top: StackNode? ;
var size: Int;
init()
{
//Set node values
self.top = nil;
self.size = 0;
}
// Add node at the top of stack
func push(_ element: Int)
{
self.top = StackNode(element, self.top);
self.size += 1;
}
func isEmpty()->Bool
{
if (self.size > 0 && self.top != nil)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
func pop()
{
if (self.size > 0 && self.top != nil)
{
var temp: StackNode? = self.top;
// Change top element of stack
self.top = temp!.next;
// remove previous top
temp = nil;
self.size -= 1;
}
}
// return top element of stack
func peek()->Int
{
return self.top!.element;
}
}
class DeleteElement
{
var stack: MyStack;
init()
{
self.stack = MyStack();
}
// Print element of stack
func printData()
{
var temp: StackNode? = self.stack.top;
while (temp != nil)
{
// Display element value
print(" ", temp!.element, terminator: "");
temp = temp!.next;
}
print(terminator: "\n");
}
// Remove middle element of stack
func removeMiddle(_ mid: Int, _ counter: Int)
{
if (counter == mid)
{
// When get middle element
print("\n Delete middle element : ", self.stack.peek(), terminator: "");
// Delete middle node
self.stack.pop();
}
else if (counter < mid && self.stack.isEmpty() == false)
{
// When stack not empty and counter is less than middle position
// Get top element
let element: Int = self.stack.peek();
// Remove top element
self.stack.pop();
// Recursively finding the middle element
self.removeMiddle(mid, counter + 1);
// Add element in stack
self.stack.push(element);
}
}
// Handles the request to delete middle element of stack
func deleteMiddle()
{
if (self.stack.isEmpty() == false)
{
// Get middle element location
let mid: Int = self.stack.size / 2;
self.removeMiddle(mid, 0);
}
else
{
print("\n Stack Is Empty ");
}
}
}
func main()
{
let task: DeleteElement = DeleteElement();
// Add stack element
task.stack.push(7);
task.stack.push(6);
task.stack.push(5);
task.stack.push(4);
task.stack.push(3);
task.stack.push(2);
task.stack.push(1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
print("\n Stack element ");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
print("\n After Delete stack ");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
print("\n After Delete stack ");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
6
7
*/
print("\n After Delete stack ");
task.printData();
}
main();
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
/*
Kotlin Program
Delete middle element of a stack
*/
// Define stack node
class StackNode
{
var element: Int;
var next: StackNode ? ;
constructor(element: Int, next: StackNode ? )
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
class MyStack
{
var top: StackNode ? ;
var size: Int;
constructor()
{
//Set node values
this.top = null;
this.size = 0;
}
// Add node at the top of stack
fun push(element: Int): Unit
{
this.top = StackNode(element, this.top);
this.size += 1;
}
fun isEmpty(): Boolean
{
if (this.size>0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
fun pop(): Unit
{
if (this.size>0 && this.top != null)
{
var temp: StackNode ? = this.top;
// Change top element of stack
this.top = temp?.next;
this.size -= 1;
}
}
// return top element of stack
fun peek(): Int
{
return this.top!!.element;
}
}
class DeleteElement
{
var stack: MyStack;
constructor()
{
this.stack = MyStack();
}
// Print element of stack
fun printData(): Unit
{
var temp: StackNode? = this.stack.top;
while (temp != null)
{
// Display element value
print(" " + temp.element);
temp = temp.next;
}
print("\n");
}
// Remove middle element of stack
fun removeMiddle(mid: Int, counter: Int): Unit
{
if (counter == mid)
{
// When get middle element
print("\n Delete middle element : " + this.stack.peek());
// Delete middle node
this.stack.pop();
}
else
if (counter<mid && this.stack.isEmpty() == false)
{
// When stack not empty and counter is less than middle position
// Get top element
var element: Int = this.stack.peek();
// Remove top element
this.stack.pop();
// Recursively finding the middle element
this.removeMiddle(mid, counter + 1);
// Add element in stack
this.stack.push(element);
}
}
// Handles the request to delete middle element of stack
fun deleteMiddle(): Unit
{
if (this.stack.isEmpty() == false)
{
// Get middle element location
var mid: Int = this.stack.size / 2;
this.removeMiddle(mid, 0);
}
else
{
print("\n Stack Is Empty \n");
}
}
}
fun main(args: Array<String>): Unit
{
var task: DeleteElement = DeleteElement();
// Add stack element
task.stack.push(7);
task.stack.push(6);
task.stack.push(5);
task.stack.push(4);
task.stack.push(3);
task.stack.push(2);
task.stack.push(1);
/*
Created Stack
============
1 <- Top
2
3
4
5
6
7
*/
print("\n Stack element \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
5
6
7
*/
print("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
3
6
7
*/
print("\n After Delete stack \n");
task.printData();
// delete operation
task.deleteMiddle();
/*
After delete middle element
============
1 <- Top
2
6
7
*/
print("\n After Delete stack \n");
task.printData();
}
Output
Stack element
1 2 3 4 5 6 7
Delete middle element : 4
After Delete stack
1 2 3 5 6 7
Delete middle element : 5
After Delete stack
1 2 3 6 7
Delete middle element : 3
After Delete stack
1 2 6 7
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