Sort stack using another stack

Here given code implementation process.

// C program 
// Sort stack using another 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;
}
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--;
	}
}
// Sort the stack elements by using of another auxiliary stack
void sortStack(struct MyStack *stack)
{
	// Create auxiliary stack
	struct MyStack *auxiliary = newStack();
	int data;
	// Executing the loop until when input element are not empty
	while (isEmpty(stack) == 0)
	{
		// Get the top element of input stack
		data = peek(stack);
		// Remove top of current input stack
		pop(stack);
		if (isEmpty(auxiliary) == 1 || peek(auxiliary) <= data)
		{
			// When stack is empty
			// Or when of auxiliary stack have top element are 
			// less than or equal to pop of current stack element
			// Add data to auxiliary stack
			push(auxiliary, data);
		}
		else
		{
			// In case, pop of stack element is less than top of auxiliary stack then
			// Remove auxiliary top elements until the top elements are not greater to data
			while (isEmpty(auxiliary) == 0 && peek(auxiliary) > data)
			{
				// Add auxiliary stack element to input stack
				push(stack, peek(auxiliary));
				// Add top of auxiliary stack
				pop(auxiliary);
			}
			// Add data to auxiliary stack
			push(auxiliary, data);
		}
	}
	// Add back to insert auxiliary element to input stack
	while (isEmpty(auxiliary) == 0)
	{
		// Add auxiliary stack element to input stack
		push(stack, peek(auxiliary));
		// Add top of auxiliary stack
		pop(auxiliary);
	}
}
// Print element of stack
void printData(struct MyStack *stack)
{
	struct StackNode *temp = stack->top;
	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, 4);
	push(stack, 7);
	push(stack, 9);
	push(stack, 1);
	push(stack, 12);
	push(stack, 3);
	push(stack, 8);
	push(stack, 5);
	push(stack, 6);
	push(stack, 10);
	printf("\n Before Sort \n");
	printData(stack);
	// Sort operation
	sortStack(stack);
	printf("\n After Sort \n");
	printData(stack);
	return 0;
}

Output

 Before Sort
  10  6  5  8  3  12  1  9  7  4

 After Sort
  1  3  4  5  6  7  8  9  10  12
/*
   Java Program
   Sort stack using another 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 SortStackElement
{
	public MyStack stack;
	public SortStackElement()
	{
		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");
	}
	// Sort the stack elements by using of another auxiliary stack
	public void sortStack()
	{
		// Create auxiliary stack
		MyStack auxiliary = new MyStack();
		int data;
		// Executing the loop until when input element are not empty
		while (this.stack.isEmpty() == false)
		{
			// Get the top element of input stack
			data = this.stack.peek();
			// Remove top of current input stack
			this.stack.pop();
			if (auxiliary.isEmpty() == true || auxiliary.peek() <= data)
			{
				// When stack is empty
				// Or when of auxiliary stack have top element are 
				// less than or equal to pop of current stack element
				// Add data to auxiliary stack
				auxiliary.push(data);
			}
			else
			{
				// In case, pop of stack element is less than top of auxiliary stack then
				// Remove auxiliary top elements until the top elements are not greater to data
				while (auxiliary.isEmpty() == false && auxiliary.peek() > data)
				{
					// Add auxiliary stack element to input stack
					this.stack.push(auxiliary.peek());
					// Add top of auxiliary stack
					auxiliary.pop();
				}
				// Add data to auxiliary stack
				auxiliary.push(data);
			}
		}
		// Add back to insert auxiliary element to input stack
		while (auxiliary.isEmpty() == false)
		{
			// Add auxiliary stack element to input stack
			stack.push(auxiliary.peek());
			// Add top of auxiliary stack
			auxiliary.pop();
		}
	}
	public static void main(String[] args)
	{
		SortStackElement task = new SortStackElement();
		// Add the stack element
		task.stack.push(4);
		task.stack.push(7);
		task.stack.push(9);
		task.stack.push(1);
		task.stack.push(12);
		task.stack.push(3);
		task.stack.push(8);
		task.stack.push(5);
		task.stack.push(6);
		task.stack.push(10);
		/*
		Created Stack
		============

		10  <- Top
		6  
		5  
		8  
		3  
		12 
		1  
		9  
		7  
		4

		*/
		System.out.print("\n Before Sort \n");
		task.printData();
		// Sort operation
		task.sortStack();
		/*
		Sort Stack
		============
		1  <- Top
		3  
		4  
		5  
		6  
		7  
		8  
		9  
		10  
		12
		*/
		System.out.print("\n After Sort \n");
		task.printData();
	}
}

Output

 Before Sort
   10   6   5   8   3   12   1   9   7   4

 After Sort
   1   3   4   5   6   7   8   9   10   12
// Include header file
#include <iostream>
using namespace std;

/*
   C++ Program
   Sort stack using another 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
            temp = NULL;
            this->size--;
        }
    }
    // return top element of stack
    int peek()
    {
        return this->top->element;
    }
};
class SortStackElement
{
    public: 
    MyStack *stack;
    SortStackElement()
    {
        this->stack = new 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";
    }
    // Sort the stack elements by using of another auxiliary stack
    void sortStack()
    {
        // Create auxiliary stack
        MyStack auxiliary =  MyStack();
        int data;
        // Executing the loop until when input element are not empty
        while (this->stack->isEmpty() == false)
        {
            // Get the top element of input stack
            data = this->stack->peek();
            // Remove top of current input stack
            this->stack->pop();
            if (auxiliary.isEmpty() == true || auxiliary.peek() <= data)
            {
                // When stack is empty
                // Or when of auxiliary stack have top element are
                // less than or equal to pop of current stack element
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
            else
            {
                // In case, pop of stack element is less than top of auxiliary stack then
                // Remove auxiliary top elements until the top elements are not greater to data
                while (auxiliary.isEmpty() == false && auxiliary.peek() > data)
                {
                    // Add auxiliary stack element to input stack
                    this->stack->push(auxiliary.peek());
                    // Add top of auxiliary stack
                    auxiliary.pop();
                }
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
        }
        // Add back to insert auxiliary element to input stack
        while (auxiliary.isEmpty() == false)
        {
            // Add auxiliary stack element to input stack
            this->stack->push(auxiliary.peek());
            // Add top of auxiliary stack
            auxiliary.pop();
        }
    }
};
int main()
{
    SortStackElement task = SortStackElement();
    // Add the stack element
    task.stack->push(4);
    task.stack->push(7);
    task.stack->push(9);
    task.stack->push(1);
    task.stack->push(12);
    task.stack->push(3);
    task.stack->push(8);
    task.stack->push(5);
    task.stack->push(6);
    task.stack->push(10);
    /*
    Created Stack
    ============

    10  <- Top
    6  
    5  
    8  
    3  
    12 
    1  
    9  
    7  
    4

    */
    cout << "\n Before Sort \n";
    task.printData();
    // Sort operation
    task.sortStack();
    /*
    Sort Stack
    ============
    1  <- Top
    3  
    4  
    5  
    6  
    7  
    8  
    9  
    10  
    12
    */
    cout << "\n After Sort \n";
    task.printData();
    return 0;
}

Output

 Before Sort
   10   6   5   8   3   12   1   9   7   4

 After Sort
   1   3   4   5   6   7   8   9   10   12
// Include namespace system
using System;
/*
   C# Program
   Sort stack using another 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 SortStackElement
{
	public MyStack stack;
	public SortStackElement()
	{
		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");
	}
	// Sort the stack elements by using of another auxiliary stack
	public void sortStack()
	{
		// Create auxiliary stack
		MyStack auxiliary = new MyStack();
		int data = 0;
		// Executing the loop until when input element are not empty
		while (this.stack.isEmpty() == false)
		{
			// Get the top element of input stack
			data = this.stack.peek();
			// Remove top of current input stack
			this.stack.pop();
			if (auxiliary.isEmpty() == true || auxiliary.peek() <= data)
			{
				// When stack is empty
				// Or when of auxiliary stack have top element are
				// less than or equal to pop of current stack element
				// Add data to auxiliary stack
				auxiliary.push(data);
			}
			else
			{
				// In case, pop of stack element is less than top of auxiliary stack then
				// Remove auxiliary top elements until the top elements are not greater to data
				while (auxiliary.isEmpty() == false && auxiliary.peek() > data)
				{
					// Add auxiliary stack element to input stack
					this.stack.push(auxiliary.peek());
					// Add top of auxiliary stack
					auxiliary.pop();
				}
				// Add data to auxiliary stack
				auxiliary.push(data);
			}
		}
		// Add back to insert auxiliary element to input stack
		while (auxiliary.isEmpty() == false)
		{
			// Add auxiliary stack element to input stack
			stack.push(auxiliary.peek());
			// Add top of auxiliary stack
			auxiliary.pop();
		}
	}
	public static void Main(String[] args)
	{
		SortStackElement task = new SortStackElement();
		// Add the stack element
		task.stack.push(4);
		task.stack.push(7);
		task.stack.push(9);
		task.stack.push(1);
		task.stack.push(12);
		task.stack.push(3);
		task.stack.push(8);
		task.stack.push(5);
		task.stack.push(6);
		task.stack.push(10);
		/*
				Created Stack
				============

				10  <- Top
				6  
				5  
				8  
				3  
				12 
				1  
				9  
				7  
				4

				*/
		Console.Write("\n Before Sort \n");
		task.printData();
		// Sort operation
		task.sortStack();
		/*
				Sort Stack
				============
				1  <- Top
				3  
				4  
				5  
				6  
				7  
				8  
				9  
				10  
				12
				*/
		Console.Write("\n After Sort \n");
		task.printData();
	}
}

Output

 Before Sort
   10   6   5   8   3   12   1   9   7   4

 After Sort
   1   3   4   5   6   7   8   9   10   12
<?php
/*
   Php Program
   Sort stack using another 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 SortStackElement
{
    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";
    }
    // Sort the stack elements by using of another auxiliary stack
    public  function sortStack()
    {
        // Create auxiliary stack
        $auxiliary = new MyStack();
        $data;
        // Executing the loop until when input element are not empty
        while ($this->stack->isEmpty() == false)
        {
            // Get the top element of input stack
            $data = $this->stack->peek();
            // Remove top of current input stack
            $this->stack->pop();
            if ($auxiliary->isEmpty() == true || $auxiliary->peek() <= $data)
            {
                // When stack is empty
                // Or when of auxiliary stack have top element are
                // less than or equal to pop of current stack element
                // Add data to auxiliary stack
                $auxiliary->push($data);
            }
            else
            {
                // In case, pop of stack element is less than top of auxiliary stack then
                // Remove auxiliary top elements until the top elements are not greater to data
                while ($auxiliary->isEmpty() == false && $auxiliary->peek() > $data)
                {
                    // Add auxiliary stack element to input stack
                    $this->stack->push($auxiliary->peek());
                    // Add top of auxiliary stack
                    $auxiliary->pop();
                }
                // Add data to auxiliary stack
                $auxiliary->push($data);
            }
        }
        // Add back to insert auxiliary element to input stack
        while ($auxiliary->isEmpty() == false)
        {
            // Add auxiliary stack element to input stack
            $this->stack->push($auxiliary->peek());
            // Add top of auxiliary stack
            $auxiliary->pop();
        }
    }
}

function main()
{
    $task = new SortStackElement();
    // Add the stack element
    $task->stack->push(4);
    $task->stack->push(7);
    $task->stack->push(9);
    $task->stack->push(1);
    $task->stack->push(12);
    $task->stack->push(3);
    $task->stack->push(8);
    $task->stack->push(5);
    $task->stack->push(6);
    $task->stack->push(10);
    /*
    Created Stack
    ============

    10  <- Top
    6  
    5  
    8  
    3  
    12 
    1  
    9  
    7  
    4

    */
    echo "\n Before Sort \n";
    $task->printData();
    // Sort operation
    $task->sortStack();
    /*
    Sort Stack
    ============
    1  <- Top
    3  
    4  
    5  
    6  
    7  
    8  
    9  
    10  
    12
    */
    echo "\n After Sort \n";
    $task->printData();
}
main();

Output

 Before Sort
   10   6   5   8   3   12   1   9   7   4

 After Sort
   1   3   4   5   6   7   8   9   10   12
/*
   Node Js Program
   Sort stack using another 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 SortStackElement
{
    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");
    }
    // Sort the stack elements by using of another auxiliary stack
    sortStack()
    {
        // Create auxiliary stack
        var auxiliary = new MyStack();
        var data;
        // Executing the loop until when input element are not empty
        while (this.stack.isEmpty() == false)
        {
            // Get the top element of input stack
            data = this.stack.peek();
            // Remove top of current input stack
            this.stack.pop();
            if (auxiliary.isEmpty() == true || auxiliary.peek() <= data)
            {
                // When stack is empty
                // Or when of auxiliary stack have top element are
                // less than or equal to pop of current stack element
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
            else
            {
                // In case, pop of stack element is less than top of auxiliary stack then
                // Remove auxiliary top elements until the top elements are not greater to data
                while (auxiliary.isEmpty() == false && auxiliary.peek() > data)
                {
                    // Add auxiliary stack element to input stack
                    this.stack.push(auxiliary.peek());
                    // Add top of auxiliary stack
                    auxiliary.pop();
                }
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
        }
        // Add back to insert auxiliary element to input stack
        while (auxiliary.isEmpty() == false)
        {
            // Add auxiliary stack element to input stack
            this.stack.push(auxiliary.peek());
            // Add top of auxiliary stack
            auxiliary.pop();
        }
    }
}

function main()
{
    var task = new SortStackElement();
    // Add the stack element
    task.stack.push(4);
    task.stack.push(7);
    task.stack.push(9);
    task.stack.push(1);
    task.stack.push(12);
    task.stack.push(3);
    task.stack.push(8);
    task.stack.push(5);
    task.stack.push(6);
    task.stack.push(10);
    /*
    Created Stack
    ============

    10  <- Top
    6  
    5  
    8  
    3  
    12 
    1  
    9  
    7  
    4

    */
    process.stdout.write("\n Before Sort \n");
    task.printData();
    // Sort operation
    task.sortStack();
    /*
    Sort Stack
    ============
    1  <- Top
    3  
    4  
    5  
    6  
    7  
    8  
    9  
    10  
    12
    */
    process.stdout.write("\n After Sort \n");
    task.printData();
}
main();

Output

 Before Sort
   10   6   5   8   3   12   1   9   7   4

 After Sort
   1   3   4   5   6   7   8   9   10   12
#  Python 3 Program
#  Sort stack using another 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 SortStackElement :
	
	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")
	
	#  Sort the stack elements by using of another auxiliary stack
	def sortStack(self) :
		#  Create auxiliary stack
		auxiliary = MyStack()
		data = 0
		#  Executing the loop until when input element are not empty
		while (self.stack.isEmpty() == False) :
			#  Get the top element of input stack
			data = self.stack.peek()
			#  Remove top of current input stack
			self.stack.pop()
			if (auxiliary.isEmpty() == True or auxiliary.peek() <= data) :
				#  When stack is empty
				#  Or when of auxiliary stack have top element are 
				#  less than or equal to pop of current stack element
				#  Add data to auxiliary stack
				auxiliary.push(data)
			else :
				#  In case, pop of stack element is less than top of auxiliary stack then
				#  Remove auxiliary top elements until the top elements are not greater to data
				while (auxiliary.isEmpty() == False and auxiliary.peek() > data) :
					#  Add auxiliary stack element to input stack
					self.stack.push(auxiliary.peek())
					#  Add top of auxiliary stack
					auxiliary.pop()
				
				#  Add data to auxiliary stack
				auxiliary.push(data)
			
		
		#  Add back to insert auxiliary element to input stack
		while (auxiliary.isEmpty() == False) :
			#  Add auxiliary stack element to input stack
			self.stack.push(auxiliary.peek())
			#  Add top of auxiliary stack
			auxiliary.pop()
		
	

def main() :
	task = SortStackElement()
	task.stack.push(4)
	task.stack.push(7)
	task.stack.push(9)
	task.stack.push(1)
	task.stack.push(12)
	task.stack.push(3)
	task.stack.push(8)
	task.stack.push(5)
	task.stack.push(6)
	task.stack.push(10)
	# 
	# 		Created Stack
	# 		============
	# 		10  <- Top
	# 		6  
	# 		5  
	# 		8  
	# 		3  
	# 		12 
	# 		1  
	# 		9  
	# 		7  
	# 		4
	# 		
	
	print("\n Before Sort ")
	task.printData()
	#  Sort operation
	task.sortStack()
	# 
	# 		Sort Stack
	# 		============
	# 		1  <- Top
	# 		3  
	# 		4  
	# 		5  
	# 		6  
	# 		7  
	# 		8  
	# 		9  
	# 		10  
	# 		12
	# 		
	
	print("\n After Sort ")
	task.printData()

if __name__ == "__main__": main()

Output

 Before Sort
    10    6    5    8    3    12    1    9    7    4

 After Sort
    1    3    4    5    6    7    8    9    10    12
#  Ruby Program
#  Sort stack using another 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, nextNode) 
		self.element = element
		self.next = nextNode
	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 SortStackElement  
	# Define the accessor and reader of class SortStackElement  
	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

	#  Sort the stack elements by using of another auxiliary stack
	def sortStack() 
		#  Create auxiliary stack
		auxiliary = MyStack.new()
		data = 0
		#  Executing the loop until when input element are not empty
		while (self.stack.isEmpty() == false) 
			#  Get the top element of input stack
			data = self.stack.peek()
			#  Remove top of current input stack
			self.stack.pop()
			if (auxiliary.isEmpty() == true || auxiliary.peek() <= data) 
				#  When stack is empty
				#  Or when of auxiliary stack have top element are 
				#  less than or equal to pop of current stack element
				#  Add data to auxiliary stack
				auxiliary.push(data)
			else 
				#  In case, pop of stack element is less than top of auxiliary stack then
				#  Remove auxiliary top elements until the top elements are not greater to data
				while (auxiliary.isEmpty() == false && auxiliary.peek() > data) 
					#  Add auxiliary stack element to input stack
					self.stack.push(auxiliary.peek())
					#  Add top of auxiliary stack
					auxiliary.pop()
				end

				#  Add data to auxiliary stack
				auxiliary.push(data)
			end

		end

		#  Add back to insert auxiliary element to input stack
		while (auxiliary.isEmpty() == false) 
			#  Add auxiliary stack element to input stack
			stack.push(auxiliary.peek())
			#  Add top of auxiliary stack
			auxiliary.pop()
		end

	end

end

def main() 
	task = SortStackElement.new()
	task.stack.push(4)
	task.stack.push(7)
	task.stack.push(9)
	task.stack.push(1)
	task.stack.push(12)
	task.stack.push(3)
	task.stack.push(8)
	task.stack.push(5)
	task.stack.push(6)
	task.stack.push(10)
	# 
	# 		Created Stack
	# 		============
	# 		10  <- Top
	# 		6  
	# 		5  
	# 		8  
	# 		3  
	# 		12 
	# 		1  
	# 		9  
	# 		7  
	# 		4
	# 		
	
	print("\n Before Sort \n")
	task.printData()
	#  Sort operation
	task.sortStack()
	# 
	# 		Sort Stack
	# 		============
	# 		1  <- Top
	# 		3  
	# 		4  
	# 		5  
	# 		6  
	# 		7  
	# 		8  
	# 		9  
	# 		10  
	# 		12
	# 		
	
	print("\n After Sort \n")
	task.printData()
end

main()

Output

 Before Sort 
   10   6   5   8   3   12   1   9   7   4

 After Sort 
   1   3   4   5   6   7   8   9   10   12
/*
   Scala Program
   Sort stack using another 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 SortStackElement(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");
    }
    // Sort the stack elements by using of another auxiliary stack
    def sortStack(): Unit = {
        // Create auxiliary stack
        var auxiliary: MyStack = new MyStack();
        var data: Int = 0;
        // Executing the loop until when input element are not empty
        while (this.stack.isEmpty() == false)
        {
            // Get the top element of input stack
            data = this.stack.peek();
            // Remove top of current input stack
            this.stack.pop();
            if (auxiliary.isEmpty() == true || auxiliary.peek() <= data)
            {
                // When stack is empty
                // Or when of auxiliary stack have top element are
                // less than or equal to pop of current stack element
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
            else
            {
                // In case, pop of stack element is less than top of auxiliary stack then
                // Remove auxiliary top elements until the top elements are not greater to data
                while (auxiliary.isEmpty() == false && auxiliary.peek() > data)
                {
                    // Add auxiliary stack element to input stack
                    this.stack.push(auxiliary.peek());
                    // Add top of auxiliary stack
                    auxiliary.pop();
                }
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
        }
        // Add back to insert auxiliary element to input stack
        while (auxiliary.isEmpty() == false)
        {
            // Add auxiliary stack element to input stack
            stack.push(auxiliary.peek());
            // Add top of auxiliary stack
            auxiliary.pop();
        }
    }
}
object Main
{
    def main(args: Array[String]): Unit = {
        var task: SortStackElement = new SortStackElement();
        // Add the stack element
        task.stack.push(4);
        task.stack.push(7);
        task.stack.push(9);
        task.stack.push(1);
        task.stack.push(12);
        task.stack.push(3);
        task.stack.push(8);
        task.stack.push(5);
        task.stack.push(6);
        task.stack.push(10);
        /*
        Created Stack
        ============

        10  <- Top
        6  
        5  
        8  
        3  
        12 
        1  
        9  
        7  
        4

        */
        print("\n Before Sort \n");
        task.printData();
        // Sort operation
        task.sortStack();
        /*
        Sort Stack
        ============
        1  <- Top
        3  
        4  
        5  
        6  
        7  
        8  
        9  
        10  
        12
        */
        print("\n After Sort \n");
        task.printData();
    }
}

Output

 Before Sort
   10   6   5   8   3   12   1   9   7   4

 After Sort
   1   3   4   5   6   7   8   9   10   12
/*
   Swift 4 Program
   Sort stack using another 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 SortStackElement
{
    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");
    }
    // Sort the stack elements by using of another auxiliary stack
    func sortStack()
    {
        // Create auxiliary stack
        let auxiliary: MyStack = MyStack();
        var data: Int = 0;
        // Executing the loop until when input element are not empty
        while (self.stack.isEmpty() == false)
        {
            // Get the top element of input stack
            data = self.stack.peek();
            // Remove top of current input stack
            self.stack.pop();
            if (auxiliary.isEmpty() == true || auxiliary.peek() <= data)
            {
                // When stack is empty
                // Or when of auxiliary stack have top element are
                // less than or equal to pop of current stack element
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
            else
            {
                // In case, pop of stack element is less than top of auxiliary stack then
                // Remove auxiliary top elements until the top elements are not greater to data
                while (auxiliary.isEmpty() == false && auxiliary.peek() > data)
                {
                    // Add auxiliary stack element to input stack
                    self.stack.push(auxiliary.peek());
                    // Add top of auxiliary stack
                    auxiliary.pop();
                }
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
        }
        // Add back to insert auxiliary element to input stack
        while (auxiliary.isEmpty() == false)
        {
            // Add auxiliary stack element to input stack
            self.stack.push(auxiliary.peek());
            // Add top of auxiliary stack
            auxiliary.pop();
        }
    }
}
func main()
{
    let task: SortStackElement = SortStackElement();
    // Add the stack element
    task.stack.push(4);
    task.stack.push(7);
    task.stack.push(9);
    task.stack.push(1);
    task.stack.push(12);
    task.stack.push(3);
    task.stack.push(8);
    task.stack.push(5);
    task.stack.push(6);
    task.stack.push(10);
    /*
    Created Stack
    ============

    10  <- Top
    6  
    5  
    8  
    3  
    12 
    1  
    9  
    7  
    4

    */
    print("\n Before Sort ");
    task.printData();
    // Sort operation
    task.sortStack();
    /*
    Sort Stack
    ============
    1  <- Top
    3  
    4  
    5  
    6  
    7  
    8  
    9  
    10  
    12
    */
    print("\n After Sort ");
    task.printData();
}
main();

Output

 Before Sort
    10    6    5    8    3    12    1    9    7    4

 After Sort
    1    3    4    5    6    7    8    9    10    12
/*
   Kotlin Program
   Sort stack using another 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 SortStackElement
{
    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");
    }
    // Sort the stack elements by using of another auxiliary stack
    fun sortStack(): Unit
    {
        // Create auxiliary stack
        var auxiliary: MyStack = MyStack();
        var data: Int ;
        // Executing the loop until when input element are not empty
        while (this.stack.isEmpty() == false)
        {
            // Get the top element of input stack
            data = this.stack.peek();
            // Remove top of current input stack
            this.stack.pop();
            if (auxiliary.isEmpty() == true || auxiliary.peek() <= data)
            {
                // When stack is empty
                // Or when of auxiliary stack have top element are
                // less than or equal to pop of current stack element
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
            else
            {
                // In case, pop of stack element is less than top of auxiliary stack then
                // Remove auxiliary top elements until the top elements are not greater to data
                while (auxiliary.isEmpty() == false && auxiliary.peek() > data)
                {
                    // Add auxiliary stack element to input stack
                    this.stack.push(auxiliary.peek());
                    // Add top of auxiliary stack
                    auxiliary.pop();
                }
                // Add data to auxiliary stack
                auxiliary.push(data);
            }
        }
        // Add back to insert auxiliary element to input stack
        while (auxiliary.isEmpty() == false)
        {
            // Add auxiliary stack element to input stack
            stack.push(auxiliary.peek());
            // Add top of auxiliary stack
            auxiliary.pop();
        }
    }
}
fun main(args: Array<String>): Unit
{
    var task: SortStackElement = SortStackElement();
    // Add the stack element
    task.stack.push(4);
    task.stack.push(7);
    task.stack.push(9);
    task.stack.push(1);
    task.stack.push(12);
    task.stack.push(3);
    task.stack.push(8);
    task.stack.push(5);
    task.stack.push(6);
    task.stack.push(10);
    /*
    Created Stack
    ============

    10  <- Top
    6  
    5  
    8  
    3  
    12 
    1  
    9  
    7  
    4

    */
    print("\n Before Sort \n");
    task.printData();
    // Sort operation
    task.sortStack();
    /*
    Sort Stack
    ============
    1  <- Top
    3  
    4  
    5  
    6  
    7  
    8  
    9  
    10  
    12
    */
    print("\n After Sort \n");
    task.printData();
}

Output

 Before Sort
   10   6   5   8   3   12   1   9   7   4

 After Sort
   1   3   4   5   6   7   8   9   10   12


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