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







© 2021, kalkicode.com, All rights reserved