Delete all even elements from a stack
Here given code implementation process.
// 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
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