Skip to content
Related Articles

Related Articles

Delete all even elements from a stack
  • Difficulty Level : Easy
  • Last Updated : 14 Jun, 2019

Given a stack with n elements, the task is to remove all the elements of the stack without affecting the order of elements.

Examples:

Input : s = 16 <- 15 <- 29 <- 24 <- 19 (TOP)
Output: 19 29 15
19 29 15 is the order of odd elements in which
they will be popped from the given stack.

Input : s = 1 <- 2 <- 3 <- 4 <- 5 (TOP)
Output: 5 3 1

Approach:



  1. Create a temporary stack temp and start popping the elements of the given stack s.
  2. For every popped element say val, if val % 2 == 1 then push it to temp.
  3. At the end of step 2, temp will contain all the odd elements from s but in reverse order.
  4. Now, to get the original order, pop every element from temp and push it to s.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <stack>
#include <iostream>
#include <stdio.h>
  
using namespace std;
  
// Utility function to print
// the contents of a stack
static void printStack(stack<int> s)
{
    while (!s.empty())
    {
        cout << s.top() << " ";
        s.pop();
    }
}
  
// Function to delete all even
// elements from the stack
static void deleteEven(stack<int> s)
{
    stack<int> temp;
    // While stack is not empty
    while (!s.empty())
    {
        int val = s.top();
        s.pop();
  
        // If value is odd then push
        // it to the temporary stack
        if (val % 2 == 1)
            temp.push(val);
    }
  
    // Tranfer the contents of the temporary stack
    // to the original stack in order to get
    // the original order of the elements
    while (!temp.empty())
    {
        s.push(temp.top());
        temp.pop();
    }
  
    // Print the modified stack content
    printStack(s);
}
  
// Driver Code
int main()
{
    stack<int> s;
    s.push(16);
    s.push(15);
    s.push(29);
    s.push(24);
    s.push(19);
    deleteEven(s);
    return 0;
}
   
// This code is contributed by Vivekkumar Singh

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.Stack;
class GFG {
  
    // Utility function to print
    // the contents of a stack
    static void printStack(Stack<Integer> stack)
    {
        while (!stack.isEmpty())
            System.out.print(stack.pop() + " ");
    }
  
    // Function to delete all even
    // elements from the stack
    static void deleteEven(Stack<Integer> stack)
    {
        Stack<Integer> temp = new Stack<>();
  
        // While stack is not empty
        while (!stack.isEmpty()) {
            int val = stack.pop();
  
            // If value is odd then push
            // it to the temporary stack
            if (val % 2 == 1)
                temp.push(val);
        }
  
        // Tranfer the contents of the temporary stack
        // to the original stack in order to get
        // the original order of the elements
        while (!temp.isEmpty())
            stack.push(temp.pop());
  
        // Print the modified stack content
        printStack(stack);
    }
  
    // Driver code
    public static void main(String[] args)
    {
        Stack<Integer> stack = new Stack<>();
        stack.push(16);
        stack.push(15);
        stack.push(29);
        stack.push(24);
        stack.push(19);
  
        deleteEven(stack);
    }
}

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
using System.Collections.Generic; 
  
class GFG 
{
  
    // Utility function to print
    // the contents of a stack
    static void printStack(Stack<int> stack)
    {
        while (stack.Count != 0)
            Console.Write(stack.Pop() + " ");
    }
  
    // Function to delete all even
    // elements from the stack
    static void deleteEven(Stack<int> stack)
    {
        Stack<int> temp = new Stack<int>();
  
        // While stack is not empty
        while (stack.Count != 0) 
        {
            int val = stack.Pop();
  
            // If value is odd then push
            // it to the temporary stack
            if (val % 2 == 1)
                temp.Push(val);
        }
  
        // Tranfer the contents of the temporary stack
        // to the original stack in order to get
        // the original order of the elements
        while (temp.Count != 0)
            stack.Push(temp.Pop());
  
        // Print the modified stack content
        printStack(stack);
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        Stack<int> stack = new Stack<int>();
        stack.Push(16);
        stack.Push(15);
        stack.Push(29);
        stack.Push(24);
        stack.Push(19);
  
        deleteEven(stack);
    }
}
  
// This code has been contributed by 29AjayKumar

chevron_right


Output:

19 29 15

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :