Reverse a string using stack
Given a string which contains alphabet characters, Our goal is to reverse the string using stack. For example.
Input : Character
OutPut : retcarahC
In this post includes two mechanisms to solve this problem. Using custom stack functionality based on linked list. And another way, by using of predefined stack. Custom class implementation of Stack.
// Java program
// Reversing string using stack
// Stack node
class StackNode
{
// Stack data
public char element;
public StackNode next;
public StackNode(char 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(char 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;
this.size--;
}
}
// Return top element of stack
public char peek()
{
return this.top.element;
}
}
public class ReverseString
{
// Reverse the string element
public String reverse(String text)
{
int size = text.length();
// Auxiliary variable which is used to store result of string
String result = "";
// Create an stack
MyStack stack = new MyStack();
// Add element into stack
for (int i = 0; i < size; i++)
{
// Add element into stack
stack.push(text.charAt(i));
}
// iterating the stack elements until if not empty
while (stack.isEmpty() == false)
{
// Get top element
result += stack.peek();
// Remove current top
stack.pop();
}
return result;
}
public static void main(String[] args)
{
ReverseString task = new ReverseString();
String text = "This is a simple words";
System.out.print(" Before Reverse : [" + text + "]");
text = task.reverse(text);
System.out.print("\n After Reverse : [" + text + "]");
text = " ABC";
System.out.print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
System.out.print("\n After Reverse : [" + text + "]");
text = "BIG WIN";
System.out.print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
System.out.print("\n After Reverse : [" + text + "]");
text = "BIG DOG";
System.out.print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
System.out.print("\n After Reverse : [" + text + "]");
}
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
In above approach is based on custom stack implementation. Here first all the elements are inserted into the stack and pop() method is used to collect the resultant text.

// Include header file
#include <iostream>
#include <string>
using namespace std;
// C++ program
// Reversing string using stack
// Stack node
class StackNode
{
public:
// Stack data
char element;
StackNode *next;
StackNode(char element, StackNode *next)
{
this->element = element;
this->next = next;
}
};
// Define a custom stack
class MyStack
{
public: StackNode *top;
int size;
MyStack()
{
this->top = NULL;
this->size = 0;
}
// Add node at the top of stack
void push(char 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;
this->size--;
}
}
// Return top element of stack
char peek()
{
return this->top->element;
}
};
class ReverseString
{
public:
// Reverse the string element
string reverse(string text)
{
int size = text.length();
// Auxiliary variable which is used to store result of string
string result = "";
// Create an stack
MyStack *stack = new MyStack();
// Add element into stack
for (int i = 0; i < size; i++)
{
// Add element into stack
stack->push(text[i]);
}
// iterating the stack elements until if not empty
while (stack->isEmpty() == false)
{
// Get top element
result += stack->peek();
// Remove current top
stack->pop();
}
return result;
}
};
int main()
{
ReverseString *task = new ReverseString();
string text = "This is a simple words";
cout << " Before Reverse : [" << text << "]";
text = task->reverse(text);
cout << "\n After Reverse : [" << text << "]";
text = " ABC";
cout << "\n Before Reverse : [" << text << "]";
text = task->reverse(text);
cout << "\n After Reverse : [" << text << "]";
text = "BIG WIN";
cout << "\n Before Reverse : [" << text << "]";
text = task->reverse(text);
cout << "\n After Reverse : [" << text << "]";
text = "BIG DOG";
cout << "\n Before Reverse : [" << text << "]";
text = task->reverse(text);
cout << "\n After Reverse : [" << text << "]";
return 0;
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
// Include namespace system
using System;
// Csharp program
// Reversing string using stack
// Stack node
public class StackNode
{
// Stack data
public char element;
public StackNode next;
public StackNode(char 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(char 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;
this.size--;
}
}
// Return top element of stack
public char peek()
{
return this.top.element;
}
}
public class ReverseString
{
// Reverse the string element
public String reverse(String text)
{
int size = text.Length;
// Auxiliary variable which is used to store result of string
String result = "";
// Create an stack
MyStack stack = new MyStack();
// Add element into stack
for (int i = 0; i < size; i++)
{
// Add element into stack
stack.push(text[i]);
}
// iterating the stack elements until if not empty
while (stack.isEmpty() == false)
{
// Get top element
result += stack.peek();
// Remove current top
stack.pop();
}
return result;
}
public static void Main(String[] args)
{
ReverseString task = new ReverseString();
String text = "This is a simple words";
Console.Write(" Before Reverse : [" + text + "]");
text = task.reverse(text);
Console.Write("\n After Reverse : [" + text + "]");
text = " ABC";
Console.Write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
Console.Write("\n After Reverse : [" + text + "]");
text = "BIG WIN";
Console.Write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
Console.Write("\n After Reverse : [" + text + "]");
text = "BIG DOG";
Console.Write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
Console.Write("\n After Reverse : [" + text + "]");
}
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
<?php
// Php program
// Reversing string using stack
// Stack node
class StackNode
{
// Stack data
public $element;
public $next;
public function __construct($element, $next)
{
$this->element = $element;
$this->next = $next;
}
}
// Define a custom stack
class MyStack
{
public $top;
public $size;
public function __construct()
{
$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;
$this->size--;
}
}
// Return top element of stack
public function peek()
{
return $this->top->element;
}
}
class ReverseString
{
// Reverse the string element
public function reverse($text)
{
$size = strlen($text);
// Auxiliary variable which is used to store result of string
$result = "";
// Create an stack
$stack = new MyStack();
// Add element into stack
for ($i = 0; $i < $size; $i++)
{
// Add element into stack
$stack->push($text[$i]);
}
// iterating the stack elements until if not empty
while ($stack->isEmpty() == false)
{
// Get top element
$result .= $stack->peek();
// Remove current top
$stack->pop();
}
return $result;
}
}
function main()
{
$task = new ReverseString();
$text = "This is a simple words";
echo(" Before Reverse : [".$text.
"]");
$text = $task->reverse($text);
echo("\n After Reverse : [".$text.
"]");
$text = " ABC";
echo("\n Before Reverse : [".$text.
"]");
$text = $task->reverse($text);
echo("\n After Reverse : [".$text.
"]");
$text = "BIG WIN";
echo("\n Before Reverse : [".$text.
"]");
$text = $task->reverse($text);
echo("\n After Reverse : [".$text.
"]");
$text = "BIG DOG";
echo("\n Before Reverse : [".$text.
"]");
$text = $task->reverse($text);
echo("\n After Reverse : [".$text.
"]");
}
main();
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
// Node JS program
// Reversing string using stack
// Stack node
class StackNode
{
constructor(element, next)
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
class MyStack
{
constructor()
{
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;
this.size--;
}
}
// Return top element of stack
peek()
{
return this.top.element;
}
}
class ReverseString
{
// Reverse the string element
reverse(text)
{
var size = text.length;
// Auxiliary variable which is used to store result of string
var result = "";
// Create an stack
var stack = new MyStack();
// Add element into stack
for (var i = 0; i < size; i++)
{
// Add element into stack
stack.push(text.charAt(i));
}
// iterating the stack elements until if not empty
while (stack.isEmpty() == false)
{
// Get top element
result += stack.peek();
// Remove current top
stack.pop();
}
return result;
}
}
function main()
{
var task = new ReverseString();
var text = "This is a simple words";
process.stdout.write(" Before Reverse : [" + text + "]");
text = task.reverse(text);
process.stdout.write("\n After Reverse : [" + text + "]");
text = " ABC";
process.stdout.write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
process.stdout.write("\n After Reverse : [" + text + "]");
text = "BIG WIN";
process.stdout.write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
process.stdout.write("\n After Reverse : [" + text + "]");
text = "BIG DOG";
process.stdout.write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
process.stdout.write("\n After Reverse : [" + text + "]");
}
main();
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
package main
import "fmt"
// Go program
// Reversing string using stack
// Stack node
type StackNode struct {
// Stack data
element byte
next * StackNode
}
func getStackNode(element byte, next * StackNode) * StackNode {
var me *StackNode = &StackNode {element,next}
return me
}
// Define a custom stack
type MyStack struct {
top * StackNode
size int
}
func getMyStack() * MyStack {
var me *MyStack = &MyStack {nil,0}
return me
}
// Add node at the top of stack
func(this *MyStack) push(element byte) {
this.top = getStackNode(element, this.top)
this.size++
}
func(this MyStack) isEmpty() bool {
if this.size > 0 && this.top != nil {
return false
} else {
return true
}
}
// Remove top element of stack
func(this *MyStack) pop() {
if this.size > 0 && this.top != nil {
var temp * StackNode = this.top
// Change top element of stack
this.top = temp.next
this.size--
}
}
// Return top element of stack
func(this MyStack) peek() byte {
return this.top.element
}
type ReverseString struct {}
func getReverseString() * ReverseString {
var me *ReverseString = &ReverseString {}
return me
}
// Reverse the string element
func(this ReverseString) reverse(text string) string {
var size int = len(text)
// Auxiliary variable which is used to store result of string
var result string = ""
// Create an stack
var stack * MyStack = getMyStack()
// Add element into stack
for i := 0 ; i < size ; i++ {
// Add element into stack
stack.push(text[i])
}
// iterating the stack elements until if not empty
for (stack.isEmpty() == false) {
// Get top element
result += string(stack.peek())
// Remove current top
stack.pop()
}
return result
}
func main() {
var task * ReverseString = getReverseString()
var text string = "This is a simple words"
fmt.Print(" Before Reverse : [", text, "]")
text = task.reverse(text)
fmt.Print("\n After Reverse : [", text, "]")
text = " ABC"
fmt.Print("\n Before Reverse : [", text, "]")
text = task.reverse(text)
fmt.Print("\n After Reverse : [", text, "]")
text = "BIG WIN"
fmt.Print("\n Before Reverse : [", text, "]")
text = task.reverse(text)
fmt.Print("\n After Reverse : [", text, "]")
text = "BIG DOG"
fmt.Print("\n Before Reverse : [", text, "]")
text = task.reverse(text)
fmt.Print("\n After Reverse : [", text, "]")
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
# Python 3 program
# Reversing string using stack
# Stack node
class StackNode :
# Stack data
def __init__(self, element, next) :
self.element = element
self.next = next
# Define a custom stack
class MyStack :
def __init__(self) :
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
self.size -= 1
# Return top element of stack
def peek(self) :
return self.top.element
class ReverseString :
# Reverse the string element
def reverse(self, text) :
size = len(text)
# Auxiliary variable which is used to store result of string
result = ""
# Create an stack
stack = MyStack()
i = 0
# Add element into stack
while (i < size) :
# Add element into stack
stack.push(text[i])
i += 1
# iterating the stack elements until if not empty
while (stack.isEmpty() == False) :
# Get top element
result += stack.peek()
# Remove current top
stack.pop()
return result
def main() :
task = ReverseString()
text = "This is a simple words"
print(" Before Reverse : [", text ,"]", end = "",sep="")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]", end = "",sep="")
text = " ABC"
print("\n Before Reverse : [", text ,"]", end = "",sep="")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]", end = "",sep="")
text = "BIG WIN"
print("\n Before Reverse : [", text ,"]", end = "",sep="")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]", end = "",sep="")
text = "BIG DOG"
print("\n Before Reverse : [", text ,"]", end = "",sep="")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]", end = "",sep="")
if __name__ == "__main__": main()
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
# Ruby program
# Reversing string using stack
# Stack node
class StackNode
# Define the accessor and reader of class StackNode
attr_reader :element, :next
attr_accessor :element, :next
# Stack data
def initialize(element, n)
self.element = element
self.next = n
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()
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
self.size -= 1
end
end
# Return top element of stack
def peek()
return self.top.element
end
end
class ReverseString
# Reverse the string element
def reverse(text)
size = text.length
# Auxiliary variable which is used to store result of string
result = ""
# Create an stack
stack = MyStack.new()
i = 0
# Add element into stack
while (i < size)
# Add element into stack
stack.push(text[i])
i += 1
end
# iterating the stack elements until if not empty
while (stack.isEmpty() == false)
# Get top element
result += stack.peek()
# Remove current top
stack.pop()
end
return result
end
end
def main()
task = ReverseString.new()
text = "This is a simple words"
print(" Before Reverse : [", text ,"]")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]")
text = " ABC"
print("\n Before Reverse : [", text ,"]")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]")
text = "BIG WIN"
print("\n Before Reverse : [", text ,"]")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]")
text = "BIG DOG"
print("\n Before Reverse : [", text ,"]")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]")
end
main()
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
import scala.collection.mutable._;
// Scala program
// Reversing string using stack
// Stack node
class StackNode(
// Stack data
var element: Char,
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: Char): 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;
this.size -= 1;
}
}
// Return top element of stack
def peek(): Char = {
return this.top.element;
}
}
class ReverseString()
{
// Reverse the string element
def reverse(text: String): String = {
var size: Int = text.length();
// Auxiliary variable which is used to store result of string
var result: String = "";
// Create an stack
var stack: MyStack = new MyStack();
var i: Int = 0;
// Add element into stack
while (i < size)
{
// Add element into stack
stack.push(text.charAt(i));
i += 1;
}
// iterating the stack elements until if not empty
while (stack.isEmpty() == false)
{
// Get top element
result += stack.peek();
// Remove current top
stack.pop();
}
return result;
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: ReverseString = new ReverseString();
var text: String = "This is a simple words";
print(" Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = " ABC";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = "BIG WIN";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = "BIG DOG";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
}
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
import Foundation;
// Swift 4 program
// Reversing string using stack
// Stack node
class StackNode
{
// Stack data
var element: Character;
var next: StackNode? ;
init(_ element: Character, _ next: StackNode? )
{
self.element = element;
self.next = next;
}
}
// Define a custom stack
class MyStack
{
var top: StackNode? ;
var size: Int;
init()
{
self.top = nil;
self.size = 0;
}
// Add node at the top of stack
func push(_ element: Character)
{
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)
{
let temp: StackNode = self.top!;
// Change top element of stack
self.top = temp.next;
self.size -= 1;
}
}
// Return top element of stack
func peek() -> Character
{
return self.top!.element;
}
}
class ReverseString
{
// Reverse the string element
func reverse(_ data: String) -> String
{
let text = Array(data);
let size: Int = text.count;
// Auxiliary variable which is used to store result of string
var result: String = "";
// Create an stack
let stack: MyStack = MyStack();
var i: Int = 0;
// Add element into stack
while (i < size)
{
// Add element into stack
stack.push(text[i]);
i += 1;
}
// iterating the stack elements until if not empty
while (stack.isEmpty() == false)
{
// Get top element
result += String(stack.peek());
// Remove current top
stack.pop();
}
return result;
}
}
func main()
{
let task: ReverseString = ReverseString();
var text: String = "This is a simple words";
print(" Before Reverse : [", text ,"]", terminator: "");
text = task.reverse(text);
print("\n After Reverse : [", text ,"]", terminator: "");
text = " ABC";
print("\n Before Reverse : [", text ,"]", terminator: "");
text = task.reverse(text);
print("\n After Reverse : [", text ,"]", terminator: "");
text = "BIG WIN";
print("\n Before Reverse : [", text ,"]", terminator: "");
text = task.reverse(text);
print("\n After Reverse : [", text ,"]", terminator: "");
text = "BIG DOG";
print("\n Before Reverse : [", text ,"]", terminator: "");
text = task.reverse(text);
print("\n After Reverse : [", text ,"]", terminator: "");
}
main();
Output
Before Reverse : [ This is a simple words ]
After Reverse : [ sdrow elpmis a si sihT ]
Before Reverse : [ ABC ]
After Reverse : [ CBA ]
Before Reverse : [ BIG WIN ]
After Reverse : [ NIW GIB ]
Before Reverse : [ BIG DOG ]
After Reverse : [ GOD GIB ]
// Kotlin program
// Reversing string using stack
// Stack node
class StackNode
{
// Stack data
var element: Char;
var next: StackNode ? ;
constructor(element: Char, next: StackNode ? )
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
class MyStack
{
var top: StackNode ? ;
var size: Int;
constructor()
{
this.top = null;
this.size = 0;
}
// Add node at the top of stack
fun push(element: Char): 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)
{
val temp: StackNode? = this.top;
// Change top element of stack
this.top = temp!!.next;
this.size -= 1;
}
}
// Return top element of stack
fun peek(): Char
{
return this.top!!.element;
}
}
class ReverseString
{
// Reverse the string element
fun reverse(text: String): String
{
val size: Int = text.length;
// Auxiliary variable which is used to store result of string
var result: String = "";
// Create an stack
val stack: MyStack = MyStack();
var i: Int = 0;
// Add element into stack
while (i < size)
{
// Add element into stack
stack.push(text.get(i));
i += 1;
}
// iterating the stack elements until if not empty
while (stack.isEmpty() == false)
{
// Get top element
result += stack.peek();
// Remove current top
stack.pop();
}
return result;
}
}
fun main(args: Array < String > ): Unit
{
val task: ReverseString = ReverseString();
var text: String = "This is a simple words";
print(" Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = " ABC";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = "BIG WIN";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = "BIG DOG";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
The above program is large, because we are defining custom stack functionality. This is useful to understand stack functionality. Time complexity of this program is O(n).
Another way, by using of stack class.
import java.util.Stack;
// Java program
// Reversing string using inbuilt stack functionality
public class ReverseString
{
// Reverse the string element
public String reverse(String text)
{
int size = text.length();
// Auxiliary variable which is used to store result of string
String result = "";
// Create an empty stack
Stack < Character > stack = new Stack < Character > ();
// Add element into stack
for (int i = 0; i < size; i++)
{
// Add element into stack
stack.push(text.charAt(i));
}
// iterating the stack elements until if not empty
while (stack.isEmpty() == false)
{
// Get top element
result += stack.peek();
// Remove current top
stack.pop();
}
return result;
}
public static void main(String[] args)
{
ReverseString task = new ReverseString();
String text = "This is a simple words";
System.out.print(" Before Reverse : [" + text + "]");
text = task.reverse(text);
System.out.print("\n After Reverse : [" + text + "]");
text = " ABC";
System.out.print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
System.out.print("\n After Reverse : [" + text + "]");
text = "BIG WIN";
System.out.print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
System.out.print("\n After Reverse : [" + text + "]");
text = "BIG DOG";
System.out.print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
System.out.print("\n After Reverse : [" + text + "]");
}
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
// Include header file
#include <iostream>
#include <stack>
#include <string>
using namespace std;
// C++ program
// Reversing string using inbuilt stack functionality
class ReverseString
{
public:
// Reverse the string element
string reverse(string text)
{
int size = text.length();
// Auxiliary variable which is used to store result of string
string result = "";
// Create an empty stack
stack < char > stack;
// Add element into stack
for (int i = 0; i < size; i++)
{
// Add element into stack
stack.push(text[i]);
}
// iterating the stack elements until if not empty
while (stack.empty() == false)
{
// Get top element
result += stack.top();
// Remove current top
stack.pop();
}
return result;
}
};
int main()
{
ReverseString *task = new ReverseString();
string text = "This is a simple words";
cout << " Before Reverse : [" << text << "]";
text = task->reverse(text);
cout << "\n After Reverse : [" << text << "]";
text = " ABC";
cout << "\n Before Reverse : [" << text << "]";
text = task->reverse(text);
cout << "\n After Reverse : [" << text << "]";
text = "BIG WIN";
cout << "\n Before Reverse : [" << text << "]";
text = task->reverse(text);
cout << "\n After Reverse : [" << text << "]";
text = "BIG DOG";
cout << "\n Before Reverse : [" << text << "]";
text = task->reverse(text);
cout << "\n After Reverse : [" << text << "]";
return 0;
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
// Include namespace system
using System;
using System.Collections.Generic;
// Csharp program
// Reversing string using inbuilt stack functionality
public class ReverseString
{
// Reverse the string element
public String reverse(String text)
{
int size = text.Length;
// Auxiliary variable which is used to store result of string
String result = "";
// Create an empty stack
Stack < char > stack = new Stack < char > ();
// Add element into stack
for (int i = 0; i < size; i++)
{
// Add element into stack
stack.Push(text[i]);
}
// iterating the stack elements until if not empty
while ((stack.Count == 0) == false)
{
// Get top element
result += stack.Peek();
// Remove current top
stack.Pop();
}
return result;
}
public static void Main(String[] args)
{
ReverseString task = new ReverseString();
String text = "This is a simple words";
Console.Write(" Before Reverse : [" + text + "]");
text = task.reverse(text);
Console.Write("\n After Reverse : [" + text + "]");
text = " ABC";
Console.Write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
Console.Write("\n After Reverse : [" + text + "]");
text = "BIG WIN";
Console.Write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
Console.Write("\n After Reverse : [" + text + "]");
text = "BIG DOG";
Console.Write("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
Console.Write("\n After Reverse : [" + text + "]");
}
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
# Python 3 program
# Reversing string using inbuilt list functionality
class ReverseString :
# Reverse the string element
def reverse(self, text) :
size = len(text)
# Auxiliary variable which is used to store result of string
result = ""
# Create an empty stack
stack = []
i = 0
# Add element into stack
while (i < size) :
# Add element into stack
stack.append(text[i])
i += 1
# iterating the stack elements until if not empty
while ((len(stack) == 0) == False) :
# Get top element
result += stack[-1]
# Remove current top
stack.pop()
return result
def main() :
task = ReverseString()
text = "This is a simple words"
print(" Before Reverse : [", text ,"]", end = "")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]", end = "")
text = " ABC"
print("\n Before Reverse : [", text ,"]", end = "")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]", end = "")
text = "BIG WIN"
print("\n Before Reverse : [", text ,"]", end = "")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]", end = "")
text = "BIG DOG"
print("\n Before Reverse : [", text ,"]", end = "")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]", end = "")
if __name__ == "__main__": main()
Output
Before Reverse : [ This is a simple words ]
After Reverse : [ sdrow elpmis a si sihT ]
Before Reverse : [ ABC ]
After Reverse : [ CBA ]
Before Reverse : [ BIG WIN ]
After Reverse : [ NIW GIB ]
Before Reverse : [ BIG DOG ]
After Reverse : [ GOD GIB ]
# Ruby program
# Reversing string using inbuilt stack functionality
class ReverseString
# Reverse the string element
def reverse(text)
size = text.length
# Auxiliary variable which is used to store result of string
result = ""
# Create an empty stack
stack = []
i = 0
# Add element into stack
while (i < size)
# Add element into stack
stack.push(text[i])
i += 1
end
# iterating the stack elements until if not empty
while ((stack.length == 0) == false)
# Get top element
result += stack.last
# Remove current top
stack.pop()
end
return result
end
end
def main()
task = ReverseString.new()
text = "This is a simple words"
print(" Before Reverse : [", text ,"]")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]")
text = " ABC"
print("\n Before Reverse : [", text ,"]")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]")
text = "BIG WIN"
print("\n Before Reverse : [", text ,"]")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]")
text = "BIG DOG"
print("\n Before Reverse : [", text ,"]")
text = task.reverse(text)
print("\n After Reverse : [", text ,"]")
end
main()
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
import scala.collection.mutable._;
// Scala program
// Reversing string using inbuilt stack functionality
class ReverseString()
{
// Reverse the string element
def reverse(text: String): String = {
var size: Int = text.length();
// Auxiliary variable which is used to store result of string
var result: String = "";
// Create an empty stack
var stack: Stack[Character] = new Stack[Character]();
var i: Int = 0;
// Add element into stack
while (i < size)
{
// Add element into stack
stack.push(text.charAt(i));
i += 1;
}
// iterating the stack elements until if not empty
while (stack.isEmpty == false)
{
// Get top element
result += stack.top;
// Remove current top
stack.pop;
}
return result;
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: ReverseString = new ReverseString();
var text: String = "This is a simple words";
print(" Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = " ABC";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = "BIG WIN";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = "BIG DOG";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
}
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
import java.util.Stack;
// Kotlin program
// Reversing string using inbuilt stack functionality
class ReverseString
{
// Reverse the string element
fun reverse(text: String): String
{
val size: Int = text.length;
// Auxiliary variable which is used to store result of string
var result: String = "";
// Create an empty stack
val stack: Stack < Char > = Stack < Char > ();
var i: Int = 0;
// Add element into stack
while (i < size)
{
// Add element into stack
stack.push(text.get(i));
i += 1;
}
// iterating the stack elements until if not empty
while (stack.empty() == false)
{
// Get top element
result += stack.peek();
// Remove current top
stack.pop();
}
return result;
}
}
fun main(args: Array < String > ): Unit
{
val task: ReverseString = ReverseString();
var text: String = "This is a simple words";
print(" Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = " ABC";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = "BIG WIN";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
text = "BIG DOG";
print("\n Before Reverse : [" + text + "]");
text = task.reverse(text);
print("\n After Reverse : [" + text + "]");
}
Output
Before Reverse : [This is a simple words]
After Reverse : [sdrow elpmis a si sihT]
Before Reverse : [ ABC]
After Reverse : [CBA ]
Before Reverse : [BIG WIN]
After Reverse : [NIW GIB]
Before Reverse : [BIG DOG]
After Reverse : [GOD GIB]
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