Posted on by Kalkicode
Code Stack

Delete all even elements from a stack

The problem of Delete All Even Elements from a Stack involves removing all the even elements from a given stack while maintaining the order of the remaining elements. The task is to implement a function that takes a stack as input and removes all the even elements from it.

Problem Statement

Given a stack, implement a function deleteEven() that removes all the even elements from the stack. The original stack should be modified in-place, and only the odd elements should remain in the stack.

Example

Consider the following stack:

14 <- Top
12
9
14
5
6
17

After deleting all even elements from the stack, the result should be:

9 <- Top
5
17

Idea to Solve the Problem

To delete all even elements from the stack, we can use a recursive approach. We will perform the following steps:

  1. Check if the stack is not empty.
  2. If the stack is not empty, get the top element element.
  3. Pop the top element from the stack.
  4. Recursively call the deleteEven() function to remove even elements from the remaining stack.
  5. If element is odd (i.e., element % 2 != 0), push it back onto the stack.

Pseudocode

Function deleteEven():
    If stack is not empty:
        Get top element element from stack
        Pop the top element from stack
        Call deleteEven() recursively
        If element is odd (element % 2 != 0):
            Push element back onto stack

Code Solution

// C program 
// Delete all even elements from 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 Even element of stack
void deleteEven(struct MyStack *stack)
{
	if (isEmpty(stack) == 0)
	{
		// When stack not empty 
		// Get top element
		int element = peek(stack);
		// Remove top element
		pop(stack);
		deleteEven(stack);
		if (element % 2 != 0)
		{
			// Add odd element in stack
			push(stack, element);
		}
	}
}
// 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, 17);
	push(stack, 6);
	push(stack, 5);
	push(stack, 14);
	push(stack, 9);
	push(stack, 12);
	push(stack, 14);
	/*
	Created Stack
	============

	    14 <- Top
	    12
	    9
	    14
	    5
	    6
	    17
	*/
	printf("\n  Stack element \n");
	printData(stack);
	// delete operation
	deleteEven(stack);
	/*
	After delete even key element
	============

	    9 <- Top
	    5
	    17
	*/
	printf("\n  After delete even node in stack \n");
	printData(stack);
	return 0;
}

Output

  Stack element
  14  12  9  14  5  6  17

  After delete even node in stack
  9  5  17
/*
   Java Program
   Delete all even elements from 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 Even element of stack
    public void deleteEven()
    {
        if (this.stack.isEmpty() == false)
        {
            // When stack not empty 
            // Get top element
            int element = this.stack.peek();
            // Remove top element
            this.stack.pop();

            this.deleteEven();

            if (element % 2 != 0)
            {
                // Add odd element in stack
                this.stack.push(element);
            }
        }
    }
    public static void main(String[] args)
    {
        DeleteElement task = new DeleteElement();
        // Add the stack element
        task.stack.push(17);
        task.stack.push(6);
        task.stack.push(5);
        task.stack.push(14);
        task.stack.push(9);
        task.stack.push(12);
        task.stack.push(14);
        /*
        Created Stack
        ============

            14 <- Top
            12
            9
            14
            5
            6
            17
        */
        System.out.print("\n   Stack element \n");
        task.printData();
        // delete operation
        task.deleteEven();
        /*
        After delete even key element
        ============

            9 <- Top
            5
            17
        */
        System.out.print("\n   After delete even node in stack \n");
        task.printData();
    }
}

Output

   Stack element
   14   12   9   14   5   6   17

   After delete even node in stack
   9   5   17
// Include header file
#include <iostream>
using namespace std;

/*
   C++ Program
   Delete all even elements from 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
            delete temp;
            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 Even element of stack
    void deleteEven()
    {
        if (this->stack.isEmpty() == false)
        {
            // When stack not empty
            // Get top element
            int element = this->stack.peek();
            // Remove top element
            this->stack.pop();
          
            this->deleteEven();
          
            if (element % 2 != 0)
            {
                // Add odd element in stack
                this->stack.push(element);
            }
        }
    }
};
int main()
{
    DeleteElement task = DeleteElement();
    // Add the stack element
    task.stack.push(17);
    task.stack.push(6);
    task.stack.push(5);
    task.stack.push(14);
    task.stack.push(9);
    task.stack.push(12);
    task.stack.push(14);
    /*
    Created Stack
    ============

        14 <- Top
        12
        9
        14
        5
        6
        17
    */
    cout << "\n   Stack element \n";
    task.printData();
    // delete operation
    task.deleteEven();
    /*
    After delete even key element
    ============

        9 <- Top
        5
        17
    */
    cout << "\n   After delete even node in stack \n";
    task.printData();
    return 0;
}

Output

   Stack element
   14   12   9   14   5   6   17

   After delete even node in stack
   9   5   17
// Include namespace system
using System;
/*
   C# Program
   Delete all even elements from 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 Even element of stack
    public void deleteEven()
    {
        if (this.stack.isEmpty() == false)
        {
            // When stack not empty
            // Get top element
            int element = this.stack.peek();
            // Remove top element
            this.stack.pop();
            this.deleteEven();
            if (element % 2 != 0)
            {
                // Add odd element in stack
                this.stack.push(element);
            }
        }
    }
    public static void Main(String[] args)
    {
        DeleteElement task = new DeleteElement();
        // Add the stack element
        task.stack.push(17);
        task.stack.push(6);
        task.stack.push(5);
        task.stack.push(14);
        task.stack.push(9);
        task.stack.push(12);
        task.stack.push(14);
        /*
        Created Stack
        ============

            14 <- Top
            12
            9
            14
            5
            6
            17
        */
        Console.Write("\n   Stack element \n");
        task.printData();
        // delete operation
        task.deleteEven();
        /*
        After delete even key element
        ============

            9 <- Top
            5
            17
        */
        Console.Write("\n   After delete even node in stack \n");
        task.printData();
    }
}

Output

   Stack element
   14   12   9   14   5   6   17

   After delete even node in stack
   9   5   17
<?php
/*
   Php Program
   Delete all even elements from 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 Even element of stack
    public  function deleteEven()
    {
        if ($this->stack->isEmpty() == false)
        {
            // When stack not empty
            // Get top element
            $element = $this->stack->peek();
            // Remove top element
            $this->stack->pop();
            $this->deleteEven();
            if ($element % 2 != 0)
            {
                // Add odd element in stack
                $this->stack->push($element);
            }
        }
    }
}

function main()
{
    $task = new DeleteElement();
    // Add the stack element
    $task->stack->push(17);
    $task->stack->push(6);
    $task->stack->push(5);
    $task->stack->push(14);
    $task->stack->push(9);
    $task->stack->push(12);
    $task->stack->push(14);
    /*
    Created Stack
    ============

        14 <- Top
        12
        9
        14
        5
        6
        17
    */
    echo "\n   Stack element \n";
    $task->printData();
    // delete operation
    $task->deleteEven();
    /*
    After delete even key element
    ============

        9 <- Top
        5
        17
    */
    echo "\n   After delete even node in stack \n";
    $task->printData();
}
main();

Output

   Stack element
   14   12   9   14   5   6   17

   After delete even node in stack
   9   5   17
/*
   Node Js Program
   Delete all even elements from 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 Even element of stack
    deleteEven()
    {
        if (this.stack.isEmpty() == false)
        {
            // When stack not empty
            // Get top element
            var element = this.stack.peek();
            // Remove top element
            this.stack.pop();
            this.deleteEven();
            if (element % 2 != 0)
            {
                // Add odd element in stack
                this.stack.push(element);
            }
        }
    }
}

function main()
{
    var task = new DeleteElement();
    // Add the stack element
    task.stack.push(17);
    task.stack.push(6);
    task.stack.push(5);
    task.stack.push(14);
    task.stack.push(9);
    task.stack.push(12);
    task.stack.push(14);
    /*
    Created Stack
    ============

        14 <- Top
        12
        9
        14
        5
        6
        17
    */
    process.stdout.write("\n   Stack element \n");
    task.printData();
    // delete operation
    task.deleteEven();
    /*
    After delete even key element
    ============

        9 <- Top
        5
        17
    */
    process.stdout.write("\n   After delete even node in stack \n");
    task.printData();
}
main();

Output

   Stack element
   14   12   9   14   5   6   17

   After delete even node in stack
   9   5   17
#    Python 3 Program
#    Delete all even elements from 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 Even element of stack
	def deleteEven(self) :
		if (self.stack.isEmpty() == False) :
			#  When stack not empty 
			#  Get top element
			element = self.stack.peek()
			#  Remove top element
			self.stack.pop()
			self.deleteEven()
			if (element % 2 != 0) :
				#  Add odd element in stack
				self.stack.push(element)
			
		
	

def main() :
	task = DeleteElement()
	task.stack.push(17)
	task.stack.push(6)
	task.stack.push(5)
	task.stack.push(14)
	task.stack.push(9)
	task.stack.push(12)
	task.stack.push(14)
	# 
	#         Created Stack
	#         ============
	#             14 <- Top
	#             12
	#             9
	#             14
	#             5
	#             6
	#             17
	#         
	
	print("\n   Stack element ")
	task.printData()
	#  delete operation
	task.deleteEven()
	# 
	#         After delete even key element
	#         ============
	#             9 <- Top
	#             5
	#             17
	#         
	
	print("\n   After delete even node in stack ")
	task.printData()

if __name__ == "__main__": main()

Output

   Stack element
    14    12    9    14    5    6    17

   After delete even node in stack
    9    5    17
#  Ruby Program
#  Delete all even elements from 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, top) 
		self.element = element
		self.next = top
	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 Even element of stack
	def deleteEven() 
		if (self.stack.isEmpty() == false) 
			#  When stack not empty 
			#  Get top element
			element = self.stack.peek()
			#  Remove top element
			self.stack.pop()
			self.deleteEven()
			if (element % 2 != 0) 
				#  Add odd element in stack
				self.stack.push(element)
			end

		end

	end

end

def main() 
	task = DeleteElement.new()
	task.stack.push(17)
	task.stack.push(6)
	task.stack.push(5)
	task.stack.push(14)
	task.stack.push(9)
	task.stack.push(12)
	task.stack.push(14)
	# 
	#         Created Stack
	#         ============
	#             14 <- Top
	#             12
	#             9
	#             14
	#             5
	#             6
	#             17
	#         
	
	print("\n   Stack element \n")
	task.printData()
	#  delete operation
	task.deleteEven()
	# 
	#         After delete even key element
	#         ============
	#             9 <- Top
	#             5
	#             17
	#         
	
	print("\n   After delete even node in stack \n")
	task.printData()
end

main()

Output

   Stack element 
   14   12   9   14   5   6   17

   After delete even node in stack 
   9   5   17

/*
   Scala Program
   Delete all even elements from 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 Even element of stack
    def deleteEven(): Unit = {
        if (this.stack.isEmpty() == false)
        {
            // When stack not empty
            // Get top element
            var element: Int = this.stack.peek();
            // Remove top element
            this.stack.pop();
            this.deleteEven();
            if (element % 2 != 0)
            {
                // Add odd element in stack
                this.stack.push(element);
            }
        }
    }
}
object Main
{
    def main(args: Array[String]): Unit = {
        var task: DeleteElement = new DeleteElement();
        // Add the stack element
        task.stack.push(17);
        task.stack.push(6);
        task.stack.push(5);
        task.stack.push(14);
        task.stack.push(9);
        task.stack.push(12);
        task.stack.push(14);
        /*
        Created Stack
        ============

            14 <- Top
            12
            9
            14
            5
            6
            17
        */
        print("\n   Stack element \n");
        task.printData();
        // delete operation
        task.deleteEven();
        /*
        After delete even key element
        ============

            9 <- Top
            5
            17
        */
        print("\n   After delete even node in stack \n");
        task.printData();
    }
}

Output

   Stack element
   14   12   9   14   5   6   17

   After delete even node in stack
   9   5   17
/*
   Swift 4 Program
   Delete all even elements from 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 Even element of stack
    func deleteEven()
    {
        if (self.stack.isEmpty() == false)
        {
            // When stack not empty
            // Get top element
            let element: Int = self.stack.peek();
            // Remove top element
            self.stack.pop();
            self.deleteEven();
            if (element % 2 != 0)
            {
                // Add odd element in stack
                self.stack.push(element);
            }
        }
    }
}
func main()
{
    let task: DeleteElement = DeleteElement();
    // Add the stack element
    task.stack.push(17);
    task.stack.push(6);
    task.stack.push(5);
    task.stack.push(14);
    task.stack.push(9);
    task.stack.push(12);
    task.stack.push(14);
    /*
    Created Stack
    ============

        14 <- Top
        12
        9
        14
        5
        6
        17
    */
    print("\n   Stack element ");
    task.printData();
    // delete operation
    task.deleteEven();
    /*
    After delete even key element
    ============

        9 <- Top
        5
        17
    */
    print("\n   After delete even node in stack ");
    task.printData();
}
main();

Output

   Stack element
    14    12    9    14    5    6    17

   After delete even node in stack
    9    5    17
/*
   Kotlin Program
   Delete all even elements from 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 Even element of stack
	fun deleteEven(): Unit
	{
		if (this.stack.isEmpty() == false)
		{
			// When stack not empty
			// Get top element
			var element: Int = this.stack.peek();
			// Remove top element
			this.stack.pop();
			this.deleteEven();
			if (element % 2 != 0)
			{
				// Add odd element in stack
				this.stack.push(element);
			}
		}
	}
}
fun main(args: Array<String>): Unit
{
	var task: DeleteElement = DeleteElement();
	// Add the stack element
	task.stack.push(17);
	task.stack.push(6);
	task.stack.push(5);
	task.stack.push(14);
	task.stack.push(9);
	task.stack.push(12);
	task.stack.push(14);
	/*
	        Created Stack
	        ============

	            14 <- Top
	            12
	            9
	            14
	            5
	            6
	            17
	        */
	print("\n   Stack element \n");
	task.printData();
	// delete operation
	task.deleteEven();
	/*
	        After delete even key element
	        ============

	            9 <- Top
	            5
	            17
	        */
	print("\n   After delete even node in stack \n");
	task.printData();
}

Output

   Stack element
   14   12   9   14   5   6   17

   After delete even node in stack
   9   5   17

Time Complexity

The time complexity of the deleteEven() function is O(N), where N is the number of elements in the stack. This is because each element is visited once, and for each element, there may be a recursive call. Therefore, the overall time complexity of the deletion process is O(N).

Comment

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





Categories
Relative Post