Delete all even elements from a stack

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


My Personal Notes arrow_drop_up

Just another competitive programmer and hard worker

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.