xxxxxxxxxx
<script>
/* javascript program to implement basic stack
operations
*/
var t = -1;
var MAX = 1000;
var a = Array(MAX).fill(0); // Maximum size of Stack
function isEmpty() {
return (t < 0);
}
function push(x) {
if (t >= (MAX - 1)) {
document.write("Stack Overflow");
return false;
} else {
t+=1;
a[t] = x;
document.write(x + " pushed into stack<br/>");
return true;
}
}
function pop() {
if (t < 0) {
document.write("Stack Underflow");
return 0;
} else {
var x = a[t];
t-=1;
return x;
}
}
function peek() {
if (t < 0) {
document.write("Stack Underflow");
return 0;
} else {
var x = a[t];
return x;
}
}
function print() {
for (i = t; i > -1; i--) {
document.write(" " + a[i]);
}
}
push(10);
push(20);
push(30);
document.write(pop() + " Popped from stack");
document.write("<br/>Top element is :" + peek());
document.write("<br/>Elements present in stack : ");
print();
// This code is contributed by Rajput-Ji
</script>
xxxxxxxxxx
// Simple Stack Array with Interface in Java
public class MyMain{
public static void main(String args){
// Create a stack from the stackinterface
StackInterface myStack = new Stack();
// push items in stack
myStack.push("A");
myStack.push("B");
myStack.push("C");
myStack.push("D");
// pop item from stack
System.out.println(myStack.pop());
// peek item from tack
System.out.println(myStack.peek());
// call the toString of myStack
System.out.println(myStack);
// push items in stack
myStack.push("E");
myStack.push("F");
myStack.push("G");
// call the toString of myStack
System.out.println(myStack);
// pop everything from the stack
// for ( initialize the iterator; condition; increment/decrement)
for(;!myStack.isEmpty();){
myStack.pop();
}
// call the toString of myStack
System.out.println(myStack);
}// end of main
} // end of main
class Stack implements StackInterface{
// array of string called data, our data is stored inside the array
String[] data;
// determines the top element of the stack
int top;
// custom constructor
public Stack(int size){
data = new String[size]; // initialize the array of string, given the size
top = 0;
}
// default constructor
public Stack(){
this(10);
}
// sentinel methods
public boolean isEmpty(){
return top == 0;
}
public boolean isFull(){
return top == data.length;
}
// standard method names
public void push(String item){
data[top++] = item;
}
public String pop(){
String item = data[--top]; // get the last item in the array
data[top] = null; // remove the data inside the array
return item; // return the item
}
public String peek(){
return data[top-1];
}
@Override
public String toString(){
String result = "";
for(int i = 0; i < top; i++){
result += data[i] + ", ";
}
return result;
}
} // end of stack
interface StackInterface{
// sentinel methods
public boolean isFull();
public boolean isEmpty();
public void push(String data);
public String pop();
public String peek();
} // end of interface
xxxxxxxxxx
// C# program to implement basic stack
// operations
using System;
namespace ImplementStack {
class Stack {
private int[] ele;
private int top;
private int max;
public Stack(int size)
{
ele = new int[size]; // Maximum size of Stack
top = -1;
max = size;
}
public void push(int item)
{
if (top == max - 1) {
Console.WriteLine("Stack Overflow");
return;
}
else {
ele[++top] = item;
}
}
public int pop()
{
if (top == -1) {
Console.WriteLine("Stack is Empty");
return -1;
}
else {
Console.WriteLine("{0} popped from stack ", ele[top]);
return ele[top--];
}
}
public int peek()
{
if (top == -1) {
Console.WriteLine("Stack is Empty");
return -1;
}
else {
Console.WriteLine("{0} popped from stack ", ele[top]);
return ele[top];
}
}
public void printStack()
{
if (top == -1) {
Console.WriteLine("Stack is Empty");
return;
}
else {
for (int i = 0; i <= top; i++) {
Console.WriteLine("{0} pushed into stack", ele[i]);
}
}
}
}
// Driver program to test above functions
class Program {
static void Main()
{
Stack p = new Stack(5);
p.push(10);
p.push(20);
p.push(30);
p.printStack();
p.pop();
}
}
}
xxxxxxxxxx
# Python program for implementation of stack
# import maxsize from sys module
# Used to return -infinite when stack is empty
from sys import maxsize
# Function to create a stack. It initializes size of stack as 0
def createStack():
stack = []
return stack
# Stack is empty when stack size is 0
def isEmpty(stack):
return len(stack) == 0
# Function to add an item to stack. It increases size by 1
def push(stack, item):
stack.append(item)
print(item + " pushed to stack ")
# Function to remove an item from stack. It decreases size by 1
def pop(stack):
if (isEmpty(stack)):
return str(-maxsize -1) # return minus infinite
return stack.pop()
# Function to return the top from stack without removing it
def peek(stack):
if (isEmpty(stack)):
return str(-maxsize -1) # return minus infinite
return stack[len(stack) - 1]
# Driver program to test above functions
stack = createStack()
push(stack, str(10))
push(stack, str(20))
push(stack, str(30))
print(pop(stack) + " popped from stack")
xxxxxxxxxx
// C++ program for linked list implementation of stack
#include <bits/stdc++.h>
using namespace std;
// A structure to represent a stack
class StackNode {
public:
int data;
StackNode* next;
};
StackNode* newNode(int data)
{
StackNode* stackNode = new StackNode();
stackNode->data = data;
stackNode->next = NULL;
return stackNode;
}
int isEmpty(StackNode* root)
{
return !root;
}
void push(StackNode** root, int data)
{
StackNode* stackNode = newNode(data);
stackNode->next = *root;
*root = stackNode;
cout << data << " pushed to stack\n";
}
int pop(StackNode** root)
{
if (isEmpty(*root))
return INT_MIN;
StackNode* temp = *root;
*root = (*root)->next;
int popped = temp->data;
free(temp);
return popped;
}
int peek(StackNode* root)
{
if (isEmpty(root))
return INT_MIN;
return root->data;
}
// Driver code
int main()
{
StackNode* root = NULL;
push(&root, 10);
push(&root, 20);
push(&root, 30);
cout << pop(&root) << " popped from stack\n";
cout << "Top element is " << peek(root) << endl;
cout<<"Elements present in stack : ";
//print all elements in stack :
while(!isEmpty(root))
{
// print top element in stack
cout<<peek(root)<<" ";
// remove top element in stack
pop(&root);
}
return 0;
}
// This is code is contributed by rathbhupendra
xxxxxxxxxx
/* C++ program to implement basic stack
operations */
#include <bits/stdc++.h>
using namespace std;
#define MAX 1000
class Stack {
int top;
public:
int a[MAX]; // Maximum size of Stack
Stack() { top = -1; }
bool push(int x);
int pop();
int peek();
bool isEmpty();
};
bool Stack::push(int x)
{
if (top >= (MAX - 1)) {
cout << "Stack Overflow";
return false;
}
else {
a[++top] = x;
cout << x << " pushed into stack\n";
return true;
}
}
int Stack::pop()
{
if (top < 0) {
cout << "Stack Underflow";
return 0;
}
else {
int x = a[top--];
return x;
}
}
int Stack::peek()
{
if (top < 0) {
cout << "Stack is Empty";
return 0;
}
else {
int x = a[top];
return x;
}
}
bool Stack::isEmpty()
{
return (top < 0);
}
// Driver program to test above functions
int main()
{
class Stack s;
s.push(10);
s.push(20);
s.push(30);
cout << s.pop() << " Popped from stack\n";
//print all elements in stack :
cout<<"Elements present in stack : ";
while(!s.isEmpty())
{
// print top element in stack
cout<<s.peek()<<" ";
// remove top element in stack
s.pop();
}
return 0;
}
xxxxxxxxxx
/* Java program to implement basic stack
operations */
class Stack {
static final int MAX = 1000;
int top;
int a[] = new int[MAX]; // Maximum size of Stack
boolean isEmpty()
{
return (top < 0);
}
Stack()
{
top = -1;
}
boolean push(int x)
{
if (top >= (MAX - 1)) {
System.out.println("Stack Overflow");
return false;
}
else {
a[++top] = x;
System.out.println(x + " pushed into stack");
return true;
}
}
int pop()
{
if (top < 0) {
System.out.println("Stack Underflow");
return 0;
}
else {
int x = a[top--];
return x;
}
}
int peek()
{
if (top < 0) {
System.out.println("Stack Underflow");
return 0;
}
else {
int x = a[top];
return x;
}
}
void print(){
for(int i = top;i>-1;i--){
System.out.print(" "+ a[i]);
}
}
}
// Driver code
class Main {
public static void main(String args[])
{
Stack s = new Stack();
s.push(10);
s.push(20);
s.push(30);
System.out.println(s.pop() + " Popped from stack");
System.out.println("Top element is :" + s.peek());
System.out.print("Elements present in stack :");
s.print();
}
}
xxxxxxxxxx
begin
if stack is empty
return
endif
else
store value of stack[top]
decrement top
return value
end else
end procedure
xxxxxxxxxx
begin
if top < 1
return true
else
return false
end procedure