Sort a stack using temporary two stack

Here given code implementation process.

// C program 
// Sort a stack using temporary two stack
// Time complexity O(n)
#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--;
    }
}
// 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");
}
// Transfer all stack t1 data into a stack t2
void transferData(struct MyStack *t1, struct MyStack *t2)
{
    int data = 0;
    // Executing the loop until when t1 stack element are not empty
    while (isEmpty(t1) == 0)
    {
        // Get the top element of t1 stack
        data = peek(t1);
        // Remove top of current t1 stack
        pop(t1);
        // Add data to t2 stack
        push(t2, data);
    }
}
// This is reverse the stack elements by using of auxiliary stacks
void reverseStack(struct MyStack *stack)
{
    // Create two auxiliary stacks
    struct MyStack *auxiliary1 = newStack();
    struct MyStack *auxiliary2 = newStack();
    // Send the all elements from actual stack into auxiliary1
    transferData(stack, auxiliary1);
    // Send the all elements from auxiliary1 into auxiliary2
    transferData(auxiliary1, auxiliary2);
    // Send the all elements from auxiliary2 into actual stack
    transferData(auxiliary2, stack);
}
int main()
{
    // Create a stack
    struct MyStack *stack = newStack();
    // Add elements
    push(stack, 1);
    push(stack, 2);
    push(stack, 3);
    push(stack, 4);
    push(stack, 5);
    push(stack, 6);
    push(stack, 7);
    push(stack, 8);

    /*
    Constructed stack
    ==========
        8  <-- Top
        7  
        6  
        5  
        4  
        3  
        2  
        1
    */
    // Display stack elements
    printf(" Before Reverse \n");
    printData(stack);
    // Perform reverse operation
    reverseStack(stack);

    /*
    After reverse
    ==========
        1  <-- Top
        2  
        3  
        4  
        5  
        6  
        7  
        8
    */
    // Display stack elements
    printf("\n After Reverse \n");
    printData(stack);
    return 0;
}

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8
/*
   Java Program
   The Stock Span Problem
*/
// 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 ReverseElements
{
    // Print element of stack
    public void printData(MyStack stack)
    {
        StackNode temp = stack.top;
        // iterate stack elements
        while (temp != null)
        {
            // Display element value
            System.out.print("  " + temp.element);
            temp = temp.next;
        }
        System.out.print("\n");
    }
    // Transfer all stack t1 data into a stack t2
    public void transferData(MyStack t1, MyStack t2)
    {
        int data = 0;
        // Executing the loop until when t1 stack element are not empty
        while (t1.isEmpty() == false)
        {
            // Get the top element of t1 stack
            data = t1.peek();
            // Remove top of current t1 stack
            t1.pop();
            // Add data to t2 stack
            t2.push(data);
        }
    }
    // This is reverse the stack elements by using of auxiliary stacks
    public void reverseStack(MyStack stack)
    {
        // Create two auxiliary stacks
        MyStack auxiliary1 = new MyStack();
        MyStack auxiliary2 = new MyStack();
        // Send the all elements from actual stack into auxiliary1
        transferData(stack, auxiliary1);
        // Send the all elements from auxiliary1 into auxiliary2
        transferData(auxiliary1, auxiliary2);
        // Send the all elements from auxiliary2 into actual stack
        transferData(auxiliary2, stack);
    }
    public static void main(String[] args)
    {
        ReverseElements task = new ReverseElements();
        // Create a stack
        MyStack stack = new MyStack();
        // Add elements
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        stack.push(7);
        stack.push(8);
        /*
        Constructed stack
        ==========
            8  <-- Top
            7  
            6  
            5  
            4  
            3  
            2  
            1
        */
        // Display stack elements
        System.out.print(" Before Reverse \n");
        task.printData(stack);
        // Perform reverse operation
        task.reverseStack(stack);
        /*
        After reverse
        ==========
            1  <-- Top
            2  
            3  
            4  
            5  
            6  
            7  
            8
        */
        // Display stack elements
        System.out.print("\n After Reverse \n");
        task.printData(stack);
    }
}

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8
// Include header file
#include <iostream>
using namespace std;
/*
   C++ Program
   The Stock Span Problem
*/
// 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
            temp = NULL;
            this->size--;
        }
    }
    // return top element of stack
    int peek()
    {
        return this->top->element;
    }
};
class ReverseElements
{
    public:
        // Print element of stack
        void printData(MyStack stack)
        {
            StackNode *temp = stack.top;
            // iterate stack elements
            while (temp != NULL)
            {
                // Display element value
                cout << "  " << temp->element;
                temp = temp->next;
            }
            cout << "\n";
        }
    // Transfer all stack t1 data into a stack t2
    void transferData(MyStack &t1, MyStack &t2)
    {
        int data = 0;
        // Executing the loop until when t1 stack element are not empty
        while (t1.isEmpty() == false)
        {
            // Get the top element of t1 stack
            data = t1.peek();
            // Remove top of current t1 stack
            t1.pop();
            // Add data to t2 stack
            t2.push(data);
        }
    }
    // This is reverse the stack elements by using of auxiliary stacks
    void reverseStack(MyStack &stack)
    {
        // Create two auxiliary stacks
        MyStack auxiliary1 =  MyStack();
        MyStack auxiliary2 =  MyStack();
        // Send the all elements from actual stack into auxiliary1
        this->transferData(stack, auxiliary1);
        // Send the all elements from auxiliary1 into auxiliary2
        this->transferData(auxiliary1, auxiliary2);
        // Send the all elements from auxiliary2 into actual stack
        this->transferData(auxiliary2, stack);
     
    }
};
int main()
{
    ReverseElements task = ReverseElements();
    // Create a stack
    MyStack stack = MyStack();
    // Add elements
    stack.push(1);
    stack.push(2);
    stack.push(3);
    stack.push(4);
    stack.push(5);
    stack.push(6);
    stack.push(7);
    stack.push(8);
    /*
    Constructed stack
    ==========
        8  <-- Top
        7  
        6  
        5  
        4  
        3  
        2  
        1
    */
    // Display stack elements
    cout << " Before Reverse \n";
    task.printData(stack);
    // Perform reverse operation
    task.reverseStack(stack);
    /*
    After reverse
    ==========
        1  <-- Top
        2  
        3  
        4  
        5  
        6  
        7  
        8
    */
    // Display stack elements
    cout << "\n After Reverse \n";
    task.printData(stack);
    return 0;
}

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8
// Include namespace system
using System;
/*
   C# Program
   The Stock Span Problem
*/
// 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 ReverseElements
{
    // Print element of stack
    public void printData(MyStack stack)
    {
        StackNode temp = stack.top;
        // iterate stack elements
        while (temp != null)
        {
            // Display element value
            Console.Write("  " + temp.element);
            temp = temp.next;
        }
        Console.Write("\n");
    }
    // Transfer all stack t1 data into a stack t2
    public void transferData(MyStack t1, MyStack t2)
    {
        int data = 0;
        // Executing the loop until when t1 stack element are not empty
        while (t1.isEmpty() == false)
        {
            // Get the top element of t1 stack
            data = t1.peek();
            // Remove top of current t1 stack
            t1.pop();
            // Add data to t2 stack
            t2.push(data);
        }
    }
    // This is reverse the stack elements by using of auxiliary stacks
    public void reverseStack(MyStack stack)
    {
        // Create two auxiliary stacks
        MyStack auxiliary1 = new MyStack();
        MyStack auxiliary2 = new MyStack();
        // Send the all elements from actual stack into auxiliary1
        transferData(stack, auxiliary1);
        // Send the all elements from auxiliary1 into auxiliary2
        transferData(auxiliary1, auxiliary2);
        // Send the all elements from auxiliary2 into actual stack
        transferData(auxiliary2, stack);
    }
    public static void Main(String[] args)
    {
        ReverseElements task = new ReverseElements();
        // Create a stack
        MyStack stack = new MyStack();
        // Add elements
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        stack.push(7);
        stack.push(8);
        /*
        Constructed stack
        ==========
            8  <-- Top
            7  
            6  
            5  
            4  
            3  
            2  
            1
        */
        // Display stack elements
        Console.Write(" Before Reverse \n");
        task.printData(stack);
        // Perform reverse operation
        task.reverseStack(stack);
        /*
        After reverse
        ==========
            1  <-- Top
            2  
            3  
            4  
            5  
            6  
            7  
            8
        */
        // Display stack elements
        Console.Write("\n After Reverse \n");
        task.printData(stack);
    }
}

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8
<?php
/*
   Php Program
   The Stock Span Problem
*/
// 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 ReverseElements
{
    // Print element of stack
    public  function printData($stack)
    {
        $temp = $stack->top;
        // iterate stack elements
        while ($temp != null)
        {
            // Display element value
            echo "  ". $temp->element;
            $temp = $temp->next;
        }
        echo "\n";
    }
    // Transfer all stack t1 data into a stack t2
    public  function transferData($t1, $t2)
    {
        $data = 0;
        // Executing the loop until when t1 stack element are not empty
        while ($t1->isEmpty() == false)
        {
            // Get the top element of t1 stack
            $data = $t1->peek();
            // Remove top of current t1 stack
            $t1->pop();
            // Add data to t2 stack
            $t2->push($data);
        }
    }
    // This is reverse the stack elements by using of auxiliary stacks
    public  function reverseStack($stack)
    {
        // Create two auxiliary stacks
        $auxiliary1 = new MyStack();
        $auxiliary2 = new MyStack();
        // Send the all elements from actual stack into auxiliary1
        $this->transferData($stack, $auxiliary1);
        // Send the all elements from auxiliary1 into auxiliary2
        $this->transferData($auxiliary1, $auxiliary2);
        // Send the all elements from auxiliary2 into actual stack
        $this->transferData($auxiliary2, $stack);
    }
}

function main()
{
    $task = new ReverseElements();
    // Create a stack
    $stack = new MyStack();
    // Add elements
    $stack->push(1);
    $stack->push(2);
    $stack->push(3);
    $stack->push(4);
    $stack->push(5);
    $stack->push(6);
    $stack->push(7);
    $stack->push(8);
    /*
    Constructed stack
    ==========
        8  <-- Top
        7  
        6  
        5  
        4  
        3  
        2  
        1
    */
    // Display stack elements
    echo " Before Reverse \n";
    $task->printData($stack);
    // Perform reverse operation
    $task->reverseStack($stack);
    /*
    After reverse
    ==========
        1  <-- Top
        2  
        3  
        4  
        5  
        6  
        7  
        8
    */
    // Display stack elements
    echo "\n After Reverse \n";
    $task->printData($stack);
}
main();

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8
/*
   Node Js Program
   The Stock Span Problem
*/
// 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 ReverseElements
{
    // Print element of stack
    printData(stack)
    {
        var temp = stack.top;
        // iterate stack elements
        while (temp != null)
        {
            // Display element value
            process.stdout.write("  " + temp.element);
            temp = temp.next;
        }
        process.stdout.write("\n");
    }
    // Transfer all stack t1 data into a stack t2
    transferData(t1, t2)
    {
        var data = 0;
        // Executing the loop until when t1 stack element are not empty
        while (t1.isEmpty() == false)
        {
            // Get the top element of t1 stack
            data = t1.peek();
            // Remove top of current t1 stack
            t1.pop();
            // Add data to t2 stack
            t2.push(data);
        }
    }
    // This is reverse the stack elements by using of auxiliary stacks
    reverseStack(stack)
    {
        // Create two auxiliary stacks
        var auxiliary1 = new MyStack();
        var auxiliary2 = new MyStack();
        // Send the all elements from actual stack into auxiliary1
        this.transferData(stack, auxiliary1);
        // Send the all elements from auxiliary1 into auxiliary2
        this.transferData(auxiliary1, auxiliary2);
        // Send the all elements from auxiliary2 into actual stack
        this.transferData(auxiliary2, stack);
    }
}

function main()
{
    var task = new ReverseElements();
    // Create a stack
    var stack = new MyStack();
    // Add elements
    stack.push(1);
    stack.push(2);
    stack.push(3);
    stack.push(4);
    stack.push(5);
    stack.push(6);
    stack.push(7);
    stack.push(8);
    /*
    Constructed stack
    ==========
        8  <-- Top
        7  
        6  
        5  
        4  
        3  
        2  
        1
    */
    // Display stack elements
    process.stdout.write(" Before Reverse \n");
    task.printData(stack);
    // Perform reverse operation
    task.reverseStack(stack);
    /*
    After reverse
    ==========
        1  <-- Top
        2  
        3  
        4  
        5  
        6  
        7  
        8
    */
    // Display stack elements
    process.stdout.write("\n After Reverse \n");
    task.printData(stack);
}
main();

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8
# Python 3 Program
# The Stock Span Problem

#  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 ReverseElements :
	#  Print element of stack
	def printData(self, stack) :
		temp = stack.top
		#  iterate stack elements
		while (temp != None) :
			#  Display element value
			print("  ", temp.element, end = "")
			temp = temp.next
		
		print(end = "\n")
	
	#  Transfer all stack t1 data into a stack t2
	def transferData(self, t1, t2) :
		data = 0
		#  Executing the loop until when t1 stack element are not empty
		while (t1.isEmpty() == False) :
			#  Get the top element of t1 stack
			data = t1.peek()
			#  Remove top of current t1 stack
			t1.pop()
			#  Add data to t2 stack
			t2.push(data)
		
	
	#  This is reverse the stack elements by using of auxiliary stacks
	def reverseStack(self, stack) :
		#  Create two auxiliary stacks
		auxiliary1 = MyStack()
		auxiliary2 = MyStack()
		#  Send the all elements from actual stack into auxiliary1
		self.transferData(stack, auxiliary1)
		#  Send the all elements from auxiliary1 into auxiliary2
		self.transferData(auxiliary1, auxiliary2)
		#  Send the all elements from auxiliary2 into actual stack
		self.transferData(auxiliary2, stack)
	

def main() :
	task = ReverseElements()
	#  Create a stack
	stack = MyStack()
	#  Add elements
	stack.push(1)
	stack.push(2)
	stack.push(3)
	stack.push(4)
	stack.push(5)
	stack.push(6)
	stack.push(7)
	stack.push(8)
	# 
	#         Constructed stack
	#         ==========
	#             8  <-- Top
	#             7  
	#             6  
	#             5  
	#             4  
	#             3  
	#             2  
	#             1
	#         
	
	#  Display stack elements
	print(" Before Reverse ")
	task.printData(stack)
	#  Perform reverse operation
	task.reverseStack(stack)
	# 
	#         After reverse
	#         ==========
	#             1  <-- Top
	#             2  
	#             3  
	#             4  
	#             5  
	#             6  
	#             7  
	#             8
	#         
	
	#  Display stack elements
	print("\n After Reverse ")
	task.printData(stack)

if __name__ == "__main__": main()

Output

 Before Reverse
   8   7   6   5   4   3   2   1

 After Reverse
   1   2   3   4   5   6   7   8
#  Ruby Program
#  The Stock Span Problem

#  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 ReverseElements 
	#  Print element of stack
	def printData(stack) 
		temp = stack.top
		#  iterate stack elements
		while (temp != nil) 
			#  Display element value
			print("  ", temp.element)
			temp = temp.next
		end

		print("\n")
	end

	#  Transfer all stack t1 data into a stack t2
	def transferData(t1, t2) 
		data = 0
		#  Executing the loop until when t1 stack element are not empty
		while (t1.isEmpty() == false) 
			#  Get the top element of t1 stack
			data = t1.peek()
			#  Remove top of current t1 stack
			t1.pop()
			#  Add data to t2 stack
			t2.push(data)
		end

	end

	#  This is reverse the stack elements by using of auxiliary stacks
	def reverseStack(stack) 
		#  Create two auxiliary stacks
		auxiliary1 = MyStack.new()
		auxiliary2 = MyStack.new()
		#  Send the all elements from actual stack into auxiliary1
		self.transferData(stack, auxiliary1)
		#  Send the all elements from auxiliary1 into auxiliary2
		self.transferData(auxiliary1, auxiliary2)
		#  Send the all elements from auxiliary2 into actual stack
		self.transferData(auxiliary2, stack)
	end

end

def main() 
	task = ReverseElements.new()
	#  Create a stack
	stack = MyStack.new()
	#  Add elements
	stack.push(1)
	stack.push(2)
	stack.push(3)
	stack.push(4)
	stack.push(5)
	stack.push(6)
	stack.push(7)
	stack.push(8)
	# 
	#         Constructed stack
	#         ==========
	#             8  <-- Top
	#             7  
	#             6  
	#             5  
	#             4  
	#             3  
	#             2  
	#             1
	#         
	
	#  Display stack elements
	print(" Before Reverse \n")
	task.printData(stack)
	#  Perform reverse operation
	task.reverseStack(stack)
	# 
	#         After reverse
	#         ==========
	#             1  <-- Top
	#             2  
	#             3  
	#             4  
	#             5  
	#             6  
	#             7  
	#             8
	#         
	
	#  Display stack elements
	print("\n After Reverse \n")
	task.printData(stack)
end

main()

Output

 Before Reverse 
  8  7  6  5  4  3  2  1

 After Reverse 
  1  2  3  4  5  6  7  8
/*
   Scala Program
   The Stock Span Problem
*/
// 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 ReverseElements
{
    // Print element of stack
    def printData(stack: MyStack): Unit = {
        var temp: StackNode = stack.top;
        // iterate stack elements
        while (temp != null)
        {
            // Display element value
            print("  " + temp.element);
            temp = temp.next;
        }
        print("\n");
    }
    // Transfer all stack t1 data into a stack t2
    def transferData(t1: MyStack, t2: MyStack): Unit = {
        var data: Int = 0;
        // Executing the loop until when t1 stack element are not empty
        while (t1.isEmpty() == false)
        {
            // Get the top element of t1 stack
            data = t1.peek();
            // Remove top of current t1 stack
            t1.pop();
            // Add data to t2 stack
            t2.push(data);
        }
    }
    // This is reverse the stack elements by using of auxiliary stacks
    def reverseStack(stack: MyStack): Unit = {
        // Create two auxiliary stacks
        var auxiliary1: MyStack = new MyStack();
        var auxiliary2: MyStack = new MyStack();
        // Send the all elements from actual stack into auxiliary1
        this.transferData(stack, auxiliary1);
        // Send the all elements from auxiliary1 into auxiliary2
        this.transferData(auxiliary1, auxiliary2);
        // Send the all elements from auxiliary2 into actual stack
        this.transferData(auxiliary2, stack);
    }
}
object Main
{
    def main(args: Array[String]): Unit = {
        var task: ReverseElements = new ReverseElements();
        // Create a stack
        var stack: MyStack = new MyStack();
        // Add elements
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        stack.push(7);
        stack.push(8);
        /*
        Constructed stack
        ==========
            8  <-- Top
            7  
            6  
            5  
            4  
            3  
            2  
            1
        */
        // Display stack elements
        print(" Before Reverse \n");
        task.printData(stack);
        // Perform reverse operation
        task.reverseStack(stack);
        /*
        After reverse
        ==========
            1  <-- Top
            2  
            3  
            4  
            5  
            6  
            7  
            8
        */
        // Display stack elements
        print("\n After Reverse \n");
        task.printData(stack);
    }
}

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8
/*
   Swift 4 Program
   The Stock Span Problem
*/
// 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 ReverseElements
{
    // Print element of stack
    func printData(_ stack: MyStack)
    {
        var temp: StackNode? = stack.top;
        // iterate stack elements
        while (temp != nil)
        {
            // Display element value
            print("  ", temp!.element, terminator: "");
            temp = temp!.next;
        }
        print(terminator: "\n");
    }
    // Transfer all stack t1 data into a stack t2
    func transferData(_ t1: MyStack, _ t2: MyStack)
    {
        var data: Int = 0;
        // Executing the loop until when t1 stack element are not empty
        while (t1.isEmpty() == false)
        {
            // Get the top element of t1 stack
            data = t1.peek();
            // Remove top of current t1 stack
            t1.pop();
            // Add data to t2 stack
            t2.push(data);
        }
    }
    // This is reverse the stack elements by using of auxiliary stacks
    func reverseStack(_ stack: MyStack )
    {
        // Create two auxiliary stacks
        let auxiliary1: MyStack = MyStack();
        let auxiliary2: MyStack = MyStack();
        // Send the all elements from actual stack into auxiliary1
        self.transferData(stack, auxiliary1);
        // Send the all elements from auxiliary1 into auxiliary2
        self.transferData(auxiliary1, auxiliary2);
        // Send the all elements from auxiliary2 into actual stack
        self.transferData(auxiliary2, stack);
    }
}
func main()
{
    let task: ReverseElements = ReverseElements();
    // Create a stack
    let stack: MyStack = MyStack();
    // Add elements
    stack.push(1);
    stack.push(2);
    stack.push(3);
    stack.push(4);
    stack.push(5);
    stack.push(6);
    stack.push(7);
    stack.push(8);
    /*
    Constructed stack
    ==========
        8  <-- Top
        7  
        6  
        5  
        4  
        3  
        2  
        1
    */
    // Display stack elements
    print(" Before Reverse ");
    task.printData(stack);
    // Perform reverse operation
    task.reverseStack(stack);
    /*
    After reverse
    ==========
        1  <-- Top
        2  
        3  
        4  
        5  
        6  
        7  
        8
    */
    // Display stack elements
    print("\n After Reverse ");
    task.printData(stack);
}
main();

Output

 Before Reverse
   8   7   6   5   4   3   2   1

 After Reverse
   1   2   3   4   5   6   7   8
/*
   Kotlin Program
   The Stock Span Problem
*/
// 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 ReverseElements
{
    // Print element of stack
    fun printData(stack: MyStack): Unit
    {
        var temp: StackNode ? = stack.top;
        // iterate stack elements
        while (temp != null)
        {
            // Display element value
            print("  " + temp.element);
            temp = temp.next;
        }
        print("\n");
    }
    // Transfer all stack t1 data into a stack t2
    fun transferData(t1: MyStack , t2 : MyStack ): Unit
    {
        var data: Int ;
        // Executing the loop until when t1 stack element are not empty
        while (t1.isEmpty() == false)
        {
            // Get the top element of t1 stack
            data = t1.peek();
            // Remove top of current t1 stack
            t1.pop();
            // Add data to t2 stack
            t2.push(data);
        }
    }
    // This is reverse the stack elements by using of auxiliary stacks
    fun reverseStack(stack: MyStack): Unit
    {
        // Create two auxiliary stacks
        var auxiliary1: MyStack = MyStack();
        var auxiliary2: MyStack = MyStack();
        // Send the all elements from actual stack into auxiliary1
        this.transferData(stack, auxiliary1);
        // Send the all elements from auxiliary1 into auxiliary2
        this.transferData(auxiliary1, auxiliary2);
        // Send the all elements from auxiliary2 into actual stack
        this.transferData(auxiliary2, stack);
    }
}
fun main(args: Array<String>): Unit
{
    var task: ReverseElements = ReverseElements();
    // Create a stack
    var stack: MyStack = MyStack();
    // Add elements
    stack.push(1);
    stack.push(2);
    stack.push(3);
    stack.push(4);
    stack.push(5);
    stack.push(6);
    stack.push(7);
    stack.push(8);
    /*
    Constructed stack
    ==========
        8  <-- Top
        7  
        6  
        5  
        4  
        3  
        2  
        1
    */
    // Display stack elements
    print(" Before Reverse \n");
    task.printData(stack);
    // Perform reverse operation
    task.reverseStack(stack);
    /*
    After reverse
    ==========
        1  <-- Top
        2  
        3  
        4  
        5  
        6  
        7  
        8
    */
    // Display stack elements
    print("\n After Reverse \n");
    task.printData(stack);
}

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8


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







© 2021, kalkicode.com, All rights reserved