Delete middle element of a stack

Given a stack with push(), pop(), and empty() operations, The task is to delete the middle element of it without using any additional data structure.

Input  : Stack[] = [1, 2, 3, 4, 5]
Output : Stack[] = [1, 2, 4, 5]

Input  : Stack[] = [1, 2, 3, 4, 5, 6]
Output : Stack[] = [1, 2, 4, 5, 6]

Delete the middle element of a stack using recursion:

Below is the idea to solve the problem

Remove elements of the stack recursively until the count of removed elements becomes half the initial size of the stack, now the top element is the middle element thus pop it and push the previously removed elements in the reverse order.  

Follow the steps below to implement the idea:

• Store the stack size in a variable sizeofstack and a variable current to track the current size of stack.
• Recursively pop out the elements of the stack
  • Pop the element from the stack and increment current by one then recur for the remaining stack.
  • The base case would be when the current becomes equal to sizeofstack / 2 then pop the top element.
  • Push the element that was popped before the recursive call. 

Below is the Implementation of the above approach:

C++

// C++ code to delete middle of a stack
// without using additional data structure.
#include<bits/stdc++.h>
using namespace std;

// Deletes middle of stack of size
// n. Curr is current item number
    void deleteMid_util(stack<char>&s, int sizeOfStack, int current)
    {
        //if current pointer is half of the size of stack then we
        //are accessing the middle element of stack.
        if(current==sizeOfStack/2)
        {
            s.pop();
            return;
        }

        //storing the top element in a variable and popping it.
        int x = s.top();
        s.pop();
        current+=1;

        //calling the function recursively.
        deleteMid_util(s,sizeOfStack,current);

        //pushing the elements (except middle element) back
        //into stack after recursion calls.
        s.push(x);
    }
    void deleteMid(stack<char>&s, int sizeOfStack)
    {
        deleteMid_util(s,sizeOfStack,0);
    }

//Driver function to test above functions
int main()
{
    stack<char> st;

    //push elements into the stack
    st.push('1');
    st.push('2');
    st.push('3');
    st.push('4');
    st.push('5');
    st.push('6');
    st.push('7');

    deleteMid(st, st.size());

    // Printing stack after deletion
    // of middle.
    while (!st.empty())
    {
        char p=st.top();
        st.pop();
        cout << p << " ";
    }
    return 0;
}

Java

// Java code to delete middle of a stack
// without using additional data structure.
import java.io.*;
import java.util.*;

public class GFG {

    // Deletes middle of stack of size
    // n. Curr is current item number
    static void deleteMid(Stack<Character> st,
                              int n, int curr)
    {

        // If stack is empty or all items
        // are traversed
        if (st.empty() || curr == n)
            return;

        // Remove current item
        char x = st.pop();

        // Remove other items
        deleteMid(st, n, curr+1);

        // Put all items back except middle
        if (curr != n/2)
            st.push(x);
    }

    // Driver function to test above functions
    public static void main(String args[])
    {
        Stack<Character> st =
                  new Stack<Character>();

        // push elements into the stack
        st.push('1');
        st.push('2');
        st.push('3');
        st.push('4');
        st.push('5');
        st.push('6');
        st.push('7');

        deleteMid(st, st.size(), 0);

        // Printing stack after deletion
        // of middle.
        while (!st.empty())
        {
            char p=st.pop();
            System.out.print(p + " ");
        }
    }
}

// This code is contributed by
// Manish Shaw (manishshaw1)

Python3

# Python3 code to delete middle of a stack
# without using additional data structure.

# Deletes middle of stack of size
# n. Curr is current item number
class Stack:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def peek(self):
        return self.items[len(self.items)-1]

    def size(self):
        return len(self.items)

def deleteMid(st, n, curr) :

    # If stack is empty or all items
    # are traversed
    if (st.isEmpty() or curr == n) :
        return

    # Remove current item
    x = st.peek()
    st.pop()

    # Remove other items
    deleteMid(st, n, curr+1)

    # Put all items back except middle
    if (curr != int(n/2)) :
        st.push(x)

# Driver function to test above functions
st = Stack()

# push elements into the stack
st.push('1')
st.push('2')
st.push('3')
st.push('4')
st.push('5')
st.push('6')
st.push('7')

deleteMid(st, st.size(), 0)

# Printing stack after deletion
# of middle.
while (st.isEmpty() == False) :
    p = st.peek()
    st.pop()
    print (str(p) + " ", end="")

# This code is contributed by
# Manish Shaw (manishshaw1)

C#

// C# code to delete middle of a stack
// without using additional data structure.
using System;
using System.Collections.Generic;

class GFG {

    // Deletes middle of stack of size
    // n. Curr is current item number
    static void deleteMid(Stack<char> st,
                          int n,
                          int curr = 0)
    {

        // If stack is empty or all
        // items are traversed
        if (st.Count == 0 || curr == n)
            return;

        // Remove current item
        char x = st.Peek();
        st.Pop();

        // Remove other items
        deleteMid(st, n, curr+1);

        // Put all items
        // back except middle
        if (curr != n / 2)
            st.Push(x);
    }

    // Driver Code
    public static void Main()
    {
        Stack<char> st = new Stack<char>();

        // push elements into the stack
        st.Push('1');
        st.Push('2');
        st.Push('3');
        st.Push('4');
        st.Push('5');
        st.Push('6');
        st.Push('7');

        deleteMid(st, st.Count);

        // Printing stack after
        // deletion of middle.
        while (st.Count != 0)
        {
            char p=st.Peek();
            st.Pop();
            Console.Write(p + " ");
        }
    }
}

// This code is contributed by
// Manish Shaw (manishshaw1)

Javascript

<script>
    // Javascript code to delete middle of a stack
    // without using additional data structure.

    // Deletes middle of stack of size
    // n. Curr is current item number
    function deleteMid(st, n, curr)
    {

        // If stack is empty or all items
        // are traversed
        if (st.length == 0 || curr == n)
            return;

        // Remove current item
        let x = st[st.length - 1];
        st.pop();

        // Remove other items
        deleteMid(st, n, curr+1);

        // Put all items back except middle
        if (curr != parseInt(n/2, 10))
            st.push(x);
    }

    let st = [];

    // push elements into the stack
    st.push('1');
    st.push('2');
    st.push('3');
    st.push('4');
    st.push('5');
    st.push('6');
    st.push('7');

    deleteMid(st, st.length, 0);

    // Printing stack after deletion
    // of middle.
    while (st.length > 0)
    {
      let p = st[st.length - 1];
      st.pop();
      document.write(p + " ");
    }

    // This code is contributed by suresh07.
</script>

Output

7 6 5 3 2 1 

Time Complexity: O(N), For the recursive calls
Auxiliary Space: O(N), For the Recursion call Stack

Delete middle element of a stack using another stack:

Pop the elements above the middle element of the given stack and use a temp stack to store these popped elements. Then pop the middle element and push the elements of the temp stack in the given stack.

Follow the below steps to implement the idea:

• Initialize an empty stack temp and a variable count with 0.
• Run a while loop till count becomes equal to half the initial size of the given stack 
  • Pop the element of the given stack and push them in temp.
• Pop the top element from the given stack.
• Run a while loop till temp becomes empty. 
  • Push the element of temp and push them in the given stack .

Below is the implementation of the above approach:

C++

// C++ code to delete middle of a stack with iterative method
#include <bits/stdc++.h>
using namespace std;

// Deletes middle of stack of size n. Curr is current item number
void deleteMid(stack<char>& st)
{
    int n = st.size();
    stack<char> tempSt;
    int count = 0;

    // Put first n/2 element of st in tempSt
    while (count < n / 2) {
        char c = st.top();
        st.pop();
        tempSt.push(c);
        count++;
    }

    // Delete middle element
    st.pop();

    // Put all (n/2) element of tempSt in st
    while (!tempSt.empty()) {
        st.push(tempSt.top());
        tempSt.pop();
    }
}

// Driver Code
int main()
{
    stack<char> st;

    // Push elements into the stack
    st.push('1');
    st.push('2');
    st.push('3');
    st.push('4');
    st.push('5');
    st.push('6');
    st.push('7');

    deleteMid(st);

    // Printing stack after deletion of middle.
    while (!st.empty()) {
        char p = st.top();
        st.pop();
        cout << p << " ";
    }
    return 0;
}

Java

// Java code to delete middle of a stack with iterative
// method
import java.util.Stack;

@SuppressWarnings("unchecked")
class Rextester
{

    // Deletes middle of stack of size n. Curr is current
    // item number
    static void deleteMid(Stack<Character> st)
    {
        int n = st.size();
        Stack<Character> tempSt = new Stack();
        int count = 0;
        // put first n/2 element of st in tempSt
        while (count < n / 2) {
            char c = st.peek();
            st.pop();
            tempSt.push(c);
            count++;
        }
        // delete middle element
        st.pop();
        // put all (n/2) element of tempSt in st
        while (!tempSt.empty()) {
            st.push(tempSt.peek());
            tempSt.pop();
        }
    }

    // Driver function to test above functions
    public static void main(String args[])
    {
        Stack<Character> st = new Stack();

        // push elements into the stack
        st.push('1');
        st.push('2');
        st.push('3');
        st.push('4');
        st.push('5');
        st.push('6');
        st.push('7');

        deleteMid(st);

        // Printing stack after deletion of middle.
        while (!st.empty()) {
            char p = st.peek();
            st.pop();
            System.out.print(p + " ");
        }
    }
}

// This code is contributed by Lovely Jain

Python3

# Python code to delete middle of a stack with iterative method

# Deletes middle of stack of size n. Curr is current item number
def deleteMid(st):
    n = len(st)
    tempSt = []
    count = 0

    # Put first n/2 element of st in tempSt
    while (count < (n / 2)-1):
        c = st[0]
        st.pop(0)
        tempSt.insert(0, c)
        count = count+1

    # Delete middle element
    st.pop(0)

    # Put all (n/2) element of tempSt in st
    while (len(tempSt) != 0):
        st.insert(0, tempSt[0])
        tempSt.pop(0)


# Driver Code
st = []

# insert elements into the stack
st.insert(0, 1)
st.insert(0, 2)
st.insert(0, 3)
st.insert(0, 4)
st.insert(0, 5)
st.insert(0, 6)
st.insert(0, 7)
deleteMid(st)

# Printing stack after deletion of middle.
while (len(st) != 0):
    p = st[0]
    st.pop(0)
    print(p, " ")

# This code is added by adityamaharshi21

C#

// C# code to delete middle of a stack
// without using additional data structure.
using System;
using System.Collections.Generic;

class GFG {

  static void deleteMid(Stack<char> st,int n)
  {

    Stack<char> tempSt = new Stack<char>();
    int count = 0;

    // put first n/2 element of st in tempSt
    while (count < n / 2) {
      char c = st.Peek();
      st.Pop();
      tempSt.Push(c);
      count++;
    }

    // delete middle element
    st.Pop();

    // put all (n/2) element of tempSt in st
    while (tempSt.Count != 0) {
      st.Push(tempSt.Peek());
      tempSt.Pop();
    }

  }

  // Driver Code
  public static void Main()
  {
    Stack<char> st = new Stack<char>();

    // push elements into the stack
    st.Push('1');
    st.Push('2');
    st.Push('3');
    st.Push('4');
    st.Push('5');
    st.Push('6');
    st.Push('7');

    deleteMid(st, st.Count);

    // Printing stack after
    // deletion of middle.
    while (st.Count != 0)
    {
      char p=st.Peek();
      st.Pop();
      Console.Write(p + " ");
    }
  }
}

// This code is contributed by utkarshshriode02.

Javascript

// JS code to delete middle of a stack with iterative method

// Deletes middle of stack of size n. Curr is current item number
function deleteMid(st)
{
    let n = st.length;
    let tempSt=[];
    let count = 0;

    // Put first n/2 element of st in tempSt
    while (count < (n / 2)-1) {
        let c = st[0];
        st.shift();
        tempSt.unshift(c);
        count++;
    }

    // Delete middle element
    st.shift();

    // Put all (n/2) element of tempSt in st
    while (tempSt.length!=0) {
        st.unshift(tempSt[0]);
        tempSt.shift();
    }
}

// Driver Code
    let st=[];

    // unshift elements into the stack
    st.unshift('1');
    st.unshift('2');
    st.unshift('3');
    st.unshift('4');
    st.unshift('5');
    st.unshift('6');
    st.unshift('7');
    deleteMid(st);

    // Printing stack after deletion of middle.

    while (st.length!=0) {
        let p = st[0];
        st.shift();
        console.log(p ," ");
    }
// This code is added by adityamaharshi21

Output

7 6 5 3 2 1 

Time Complexity: O(N), For the while loop
Auxiliary Space: O(N), for temp stack space.