1) push():
This operation pushes an element on top of the stack and the top pointer points to the newly pushed element. It takes one parameter and pushes it onto the stack.
Below is the implementation of push() using Array :
C++
#include <bits/stdc++.h>
using namespace std;
class Stack {
public :
int stack[10];
int MAX = 10;
int top;
Stack() { top = -1; }
void push( int val)
{
if (top >= MAX - 1) {
cout << "Stack Overflow\n" ;
return ;
}
top++;
stack[top] = val;
cout << val
<< " pushed into stack successfully !\n" ;
}
};
int main()
{
Stack st;
st.push(1);
st.push(2);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class Stack {
int stack[] = new int [ 10 ];
int MAX = 10 ;
int top;
void stack() { top = - 1 ; }
void push( int val)
{
if (top >= MAX - 1 ) {
System.out.println( "Stack Overflow" );
return ;
}
top++;
stack[top] = val;
System.out.println(
val + " pushed into stack successfully !" );
}
}
public static void main(String[] args)
{
Stack st = new Stack();
st.push( 1 );
st.push( 2 );
}
}
|
Python
class Stack:
def __init__( self ):
self .stack = [ 0 ] * 10
self . MAX = 10
self .top = - 1
def push( self , val):
if self .top > = self . MAX - 1 :
print ( "Stack Overflow" )
return
self .top + = 1
self .stack[ self .top] = val
print ( str (val) + " pushed into stack successfully !\n" )
if __name__ = = "__main__" :
st = Stack()
st.push( 1 )
st.push( 2 )
|
C#
using System;
public class GFG
{
class Stack
{
public int [] stack = new int [10];
public int MAX = 10;
public int top;
public void _stack()
{
this .top = -1;
}
public void push( int val)
{
if ( this .top >= this .MAX - 1)
{
Console.WriteLine( "Stack Overflow" );
return ;
}
this .top++;
this .stack[ this .top] = val;
Console.WriteLine(val.ToString() + " pushed into stack successfully !" );
}
}
public static void Main(String[] args)
{
var st = new Stack();
st.push(1);
st.push(2);
}
}
|
Javascript
class Stack {
constructor() {
this .stack = [];
this .MAX = 10;
this .top = -1;
}
push(val) {
if ( this .top >= this .MAX - 1) {
console.log( "Stack Overflow" );
return ;
}
this .top++;
this .stack[ this .top] = val;
console.log(val, " pushed into stack successfully !" );
}
};
let st = new Stack();
st.push(1);
st.push(2);
|
Output
1 pushed into stack successfully !
2 pushed into stack successfully !
- Time Complexity: O(1), In the push function a single element is inserted at the last position. This takes a single memory allocation operation which is done in constant time.
- Auxiliary Space: O(1), As no extra space is being used.
Below is the implementation of push() using Linked List :
C++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int data;
Node* next;
Node( int val)
{
data = val;
next = NULL;
}
};
class Stack {
public :
Node* top;
Stack() { top = NULL; }
void push( int val)
{
Node* temp = new Node(val);
if (!top) {
top = temp;
cout << val
<< " pushed into stack successfully !\n" ;
return ;
}
temp->next = top;
top = temp;
cout << val
<< " pushed into stack successfully !\n" ;
}
};
int main()
{
Stack st;
st.push(1);
st.push(2);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class Node{
int data;
Node next;
Node( int val){
this .data = val;
this .next = null ;
}
}
static class Stack{
Node top;
Stack(){
top = null ;
}
void push( int val){
Node temp = new Node(val);
if (top!= null ){
top = temp;
System.out.println(val + " pushed into stack successfully !" );
return ;
}
temp.next = top;
top = temp;
System.out.println(val + " pushed into stack successfully !" );
}
}
public static void main (String[] args) {
Stack st = new Stack();
st.push( 1 );
st.push( 2 );
}
}
|
Python
class Node:
def __init__( self , val):
self .data = val
self . next = None
class Stack:
def __init__( self ):
self .top = None
def push( self , val):
temp = Node(val)
if not self .top:
self .top = temp
print (val, "pushed into stack successfully!" )
return
temp. next = self .top
self .top = temp
print (val, "pushed into stack successfully!" )
st = Stack()
st.push( 1 )
st.push( 2 )
|
C#
using System;
public class GFG {
class Node {
public int data;
public Node next;
public Node( int val)
{
this .data = val;
this .next = null ;
}
}
class Stack {
Node top;
public Stack() { top = null ; }
public void push( int val)
{
Node temp = new Node(val);
if (top != null ) {
top = temp;
Console.WriteLine(
val
+ " pushed into stack successfully !" );
return ;
}
temp.next = top;
top = temp;
Console.WriteLine(
val + " pushed into stack successfully !" );
}
}
static public void Main()
{
Stack st = new Stack();
st.push(1);
st.push(2);
}
}
|
Javascript
class Node {
constructor(data) {
this .data = data;
this .next = null ;
}
}
class Stack {
constructor() {
this .top= null ;
}
push(val) {
let temp = new Node(val);
if ( this .top== null ) {
this .top = temp;
console.log(val, " pushed into stack successfully !" );
return ;
}
temp.next = this .top;
this .top = temp;
console.log(val, " pushed into stack successfully !" );
}
};
let st = new Stack();
st.push(1);
st.push(2);
|
Output
1 pushed into stack successfully !
2 pushed into stack successfully !
- Time Complexity: O(1), Only a new node is created and the pointer of the last node is updated. This includes only memory allocation operations. Hence it can be said that insertion is done in constant time.
- Auxiliary Space: O(1), No extra space is used.
2) pop():
This operation removes the topmost element in the stack and returns an error if the stack is already empty.
Below is the implementation of pop() using Array:
C++
#include <bits/stdc++.h>
using namespace std;
class Stack {
public :
int stack[10];
int MAX = 10;
int top;
Stack() { top = -1; }
void push( int val)
{
if (top >= MAX - 1) {
cout << "Stack Overflow\n" ;
return ;
}
top++;
stack[top] = val;
cout << val
<< " pushed into stack successfully !\n" ;
}
void pop()
{
if (top < 0) {
cout << "Stack Underflow" ;
}
else {
int x = stack[top--];
cout << "Element popped from stack : " << x
<< "\n" ;
}
}
};
int main()
{
Stack st;
st.push(1);
st.pop();
st.pop();
return 0;
}
|
Java
import java.io.*;
class GFG {
static class Stack {
int [] stack = new int [ 10 ];
int MAX = 10 ;
int top;
Stack() { top = - 1 ; }
void push( int val)
{
if (top >= MAX - 1 ) {
System.out.println( "Stack Overflow" );
return ;
}
top++;
stack[top] = val;
System.out.println(
val + " pushed into stack successfully !" );
}
void pop()
{
if (top < 0 ) {
System.out.print( "Stack Underflow" );
}
else {
int x = stack[top--];
System.out.println(
"Element popped from stack : " + x);
}
}
}
public static void main(String[] args)
{
Stack st = new Stack();
st.push( 1 );
st.pop();
st.pop();
}
}
|
Python
class Stack:
def __init__( self ):
self .stack = [ None ] * 10
self . MAX = 10
self .top = - 1
def push( self , val):
if self .top > = self . MAX - 1 :
print ( 'Stack Overflow' )
return
self .top + = 1
self .stack[ self .top] = val
print (val, 'pushed into stack successfully !' )
def pop( self ):
if self .top < 0 :
print ( 'Stack Underflow' )
else :
x = self .stack[ self .top]
self .top - = 1
print ( 'Element popped from stack:' , x)
st = Stack()
st.push( 1 )
st.pop()
st.pop()
|
C#
using System;
public class GFG {
class Stack {
public int [] stack = new int [10];
public int MAX = 10;
public int top;
public void _stack() { this .top = -1; }
public void push( int val)
{
if ( this .top >= this .MAX - 1) {
Console.WriteLine( "Stack Overflow" );
return ;
}
this .top++;
this .stack[ this .top] = val;
Console.WriteLine(
val.ToString()
+ " pushed into stack successfully !" );
}
public void pop()
{
if ( this .top <= 0) {
Console.WriteLine( "Stack Underflow" );
}
else {
int x = this .stack[ this .top--];
Console.WriteLine(
"Element popped from stack : "
+ x.ToString());
}
}
}
public static void Main(String[] args)
{
var st = new Stack();
st.push(1);
st.pop();
st.pop();
}
}
|
Javascript
class Stack {
constructor() {
this .stack = [];
this .MAX = 10;
this .top = -1;
}
push(val) {
if ( this .top >= this .MAX - 1) {
console.log( "Stack Overflow" );
return ;
}
this .top++;
this .stack[ this .top] = val;
console.log(val, " pushed into stack successfully !" );
}
pop() {
if ( this .top < 0) {
console.log( "Stack Underflow" );
}
else {
let x = this .stack[ this .top--];
console.log( "Element popped from stack : " , x);
}
}
};
let st = new Stack();
st.push(1);
st.pop();
st.pop();
|
Output
1 pushed into stack successfully !
Element popped from stack : 1
Stack Underflow
- Time Complexity: O(1), In array implementation, only an arithmetic operation is performed i.e., the top pointer is decremented by 1. This is a constant time function.
- Auxiliary Space: O(1), No extra space is utilized for deleting an element from the stack.
Below is the implementation of pop() using Linked List :
C++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int data;
Node* next;
Node( int val)
{
data = val;
next = NULL;
}
};
class Stack {
public :
Node* top;
Stack() { top = NULL; }
void push( int val)
{
Node* temp = new Node(val);
if (!top) {
top = temp;
cout << val
<< " pushed into stack successfully !\n" ;
return ;
}
temp->next = top;
top = temp;
cout << val
<< " pushed into stack successfully !\n" ;
}
void pop()
{
Node* temp;
if (top == NULL) {
cout << "Stack Underflow\n"
<< endl;
return ;
}
else {
temp = top;
cout << "Element popped from stack : "
<< temp->data << "\n" ;
top = top->next;
free (temp);
}
}
};
int main()
{
Stack st;
st.push(1);
st.pop();
st.pop();
return 0;
}
|
Java
import java.io.*;
class GFG {
static class Node {
int data;
Node next;
Node( int val)
{
this .data = val;
this .next = null ;
}
}
static class Stack {
Node top;
Stack() { top = null ; }
void push( int val)
{
Node temp = new Node(val);
if (top != null ) {
top = temp;
System.out.println( val+ " pushed into stack successfully !" );
return ;
}
temp.next = top;
top = temp;
System.out.println(
val + " pushed into stack successfully !" );
}
void pop()
{
Node temp;
if (top == null ) {
System.out.println( "Stack Underflow" );
}
else {
temp = top;
System.out.println( "Element popped from stack : " + temp.data);
top = top.next;
}
}
}
public static void main(String[] args)
{
Stack st = new Stack();
st.push( 1 );
st.pop();
st.pop();
}
}
|
Python
class Node:
def __init__( self , val):
self .data = val
self . next = None
class Stack:
def __init__( self ):
self .top = None
def push( self , val):
temp = Node(val)
if not self .top:
self .top = temp
print (val, "pushed into stack successfully !" )
return
temp. next = self .top
self .top = temp
print (val, "pushed into stack successfully !" )
def pop( self ):
if self .top is None :
print ( "Stack Underflow" )
return
temp = self .top
print ( "Element popped from stack :" , {temp.data})
self .top = self .top. next
del temp
st = Stack()
st.push( 1 )
st.pop()
st.pop()
|
C#
using System;
class Node {
public int data;
public Node next;
public Node( int val)
{
data = val;
next = null ;
}
}
class Stack {
public Node top;
public Stack() { top = null ; }
public void push( int val)
{
Node temp = new Node(val);
if (top == null ) {
top = temp;
Console.WriteLine(
val + " pushed into stack successfully !" );
return ;
}
temp.next = top;
top = temp;
Console.WriteLine(
val + " pushed into stack successfully !" );
}
public void pop()
{
Node temp;
if (top == null ) {
Console.WriteLine( "Stack Underflow\n"
+ "\n" );
return ;
}
else {
temp = top;
Console.WriteLine( "Element popped from stack : "
+ temp.data + "\n" );
top = top.next;
temp = null ;
}
}
}
class Program {
static void Main( string [] args)
{
Stack st = new Stack();
st.push(1);
st.pop();
st.pop();
}
}
|
Javascript
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
class Stack {
constructor() {
this .top = null ;
}
push(val) {
let temp = new Node(val);
if (! this .top) {
this .top = temp;
console.log(val + " pushed into stack successfully !" );
return ;
}
temp.next = this .top;
this .top = temp;
console.log(val + " pushed into stack successfully !" );
}
pop() {
let temp;
if ( this .top == null ) {
console.log( "Stack Underflow" );
return ;
} else {
temp = this .top;
console.log( "Element popped from stack : " + temp.data);
this .top = this .top.next;
temp = null ;
}
}
}
let st = new Stack();
st.push(1);
st.pop();
st.pop();
|
Output
1 pushed into stack successfully !
Element popped from stack : 1
Stack Underflow
- Time Complexity: O(1), Only the first node is deleted and the top pointer is updated. This is a constant time operation.
- Auxiliary Space: O(1). No extra space is utilized for deleting an element from the stack.
3) peek():
This operation prints the topmost element of the stack.
Below is the Implementation of peek() using Array:
C++
#include <bits/stdc++.h>
using namespace std;
class Stack {
public :
int stack[10];
int MAX = 10;
int top;
Stack() { top = -1; }
void push( int val)
{
if (top >= MAX - 1) {
cout << "Stack Overflow\n" ;
return ;
}
top++;
stack[top] = val;
cout << val
<< " pushed into stack successfully !\n" ;
}
int peek()
{
if (top < 0) {
cout << "Stack is Empty\n" ;
return 0;
}
else {
int x = stack[top];
return x;
}
}
};
int main()
{
Stack st;
st.push(1);
st.push(2);
cout << "Peek element of stack : "
<< st.peek() << "\n" ;
return 0;
}
|
Java
import java.io.*;
class GFG {
static class Stack {
int [] stack = new int [ 10 ];
int MAX = 10 ;
int top;
Stack() { top = - 1 ; }
void push( int val)
{
if (top >= MAX - 1 ) {
System.out.println( "Stack Overflow" );
return ;
}
top++;
stack[top] = val;
System.out.println(
val + " pushed into stack successfully !" );
}
int peek()
{
if (top < 0 ) {
System.out.println( "Stack is Empty\n" );
return 0 ;
}
else {
int x = stack[top];
return x;
}
}
}
public static void main (String[] args) {
Stack st = new Stack();
st.push( 1 );
st.push( 2 );
System.out.println( "Peek element of stack : "
+ st.peek() + "\n" );
}
}
|
Python
class Stack:
def __init__( self ):
self .stack = [ 0 ] * 10
self . MAX = 10
self .top = - 1
def push( self , val):
if self .top > = self . MAX - 1 :
print ( "Stack Overflow" )
return
self .top + = 1
self .stack[ self .top] = val
print (val, " pushed into stack successfully !" )
def peek( self ):
if self .top < 0 :
print ( "Stack is Empty" )
return 0
else :
x = self .stack[ self .top]
return x
def main():
st = Stack()
st.push( 1 )
st.push( 2 )
print ( "Peek element of stack : " , st.peek())
return 0
if __name__ = = "__main__" :
main()
|
C#
using System;
public class GFG {
class Stack {
public int [] stack = new int [10];
public int MAX = 10;
public int top;
public void _stack() { this .top = -1; }
public void push( int val)
{
if ( this .top >= this .MAX - 1) {
Console.WriteLine( "Stack Overflow" );
return ;
}
this .top++;
this .stack[ this .top] = val;
Console.WriteLine(
val.ToString()
+ " pushed into stack successfully !\n" );
}
public int peek()
{
if ( this .top < 0) {
Console.WriteLine( "Stack is Empty" );
return 0;
}
else {
int x = stack[ this .top];
return x;
}
}
}
public static void Main(String[] args)
{
var st = new Stack();
st.push(1);
st.push(2);
Console.WriteLine( "Peek element of stack : "
+ st.peek());
}
}
|
Javascript
class Stack {
constructor() {
this .stack = [];
this .MAX = 10;
this .top = -1;
}
Stack() { top = -1; }
push(val) {
if ( this .top >= this .MAX - 1) {
console.log( "Stack Overflow" );
return ;
}
this .top++;
this .stack[ this .top] = val;
console.log(val, " pushed into stack successfully !" );
}
peek() {
if ( this .top < 0) {
console.log( "Stack is Empty" );
return 0;
}
else {
let x = this .stack[ this .top];
return x;
}
}
};
let st = new Stack;
st.push(1);
st.push(2);
console.log( "Peek element of stack : " , st.peek())
return 0;
|
Output
1 pushed into stack successfully !
2 pushed into stack successfully !
Peek element of stack : 2
- Time Complexity: O(1), Only a memory address is accessed. This is a constant time operation.
- Auxiliary Space: O(1), No extra space is utilized to access the value.
Below is the implementation of peek() using Linked List :
C++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int data;
Node* next;
Node( int val)
{
data = val;
next = NULL;
}
};
class Stack {
public :
Node* top;
Stack() { top = NULL; }
void push( int val)
{
Node* temp = new Node(val);
if (!top) {
top = temp;
cout << val
<< " pushed into stack successfully !\n" ;
return ;
}
temp->next = top;
top = temp;
cout << val
<< " pushed into stack successfully !\n" ;
}
bool isEmpty()
{
return top == NULL;
}
int peek()
{
if (!isEmpty())
return top->data;
else
cout << "Stack is Empty\n" ;
exit (1);
}
};
int main()
{
Stack st;
st.push(1);
cout << "Peek element of stack : "
<< st.peek() << "\n" ;
return 0;
}
|
Java
import java.util.Scanner;
class Node {
public int data;
public Node next;
public Node( int val)
{
data = val;
next = null ;
}
}
class Stack {
public Node top;
public Stack() { top = null ; }
public void push( int val)
{
Node temp = new Node(val);
if (top == null ) {
top = temp;
System.out.println(
val + " pushed into stack successfully!" );
return ;
}
temp.next = top;
top = temp;
System.out.println(
val + " pushed into stack successfully!" );
}
public boolean isEmpty()
{
return top == null ;
}
public int peek()
{
if (!isEmpty()) {
return top.data;
}
else {
System.out.println( "Stack is Empty" );
System.exit( 1 );
}
return 0 ;
}
}
public class Main {
public static void main(String[] args)
{
Stack st = new Stack();
st.push( 1 );
System.out.println( "Peek element of stack: "
+ st.peek());
}
}
|
Python
class Node:
def __init__( self , val):
self .data = val
self . next = None
class Stack:
def __init__( self ):
self .top = None
def push( self , val):
temp = Node(val)
if self .top is None :
self .top = temp
print (val, "pushed into stack successfully !" )
return
temp. next = self .top
self .top = temp
print (val, " pushed into stack successfully !" )
def is_empty( self ):
return self .top is None
def peek( self ):
if not self .is_empty():
return self .top.data
else :
print ( "Stack is Empty" )
exit( 1 )
st = Stack()
st.push( 1 )
print ( "Peek element of stack:" ,st.peek())
|
C#
using System;
class Node {
public int data;
public Node next;
public Node( int val)
{
data = val;
next = null ;
}
}
class Stack {
public Node top;
public Stack() { top = null ; }
public void push( int val)
{
Node temp = new Node(val);
if (top == null ) {
top = temp;
Console.WriteLine(val + " pushed into stack successfully !" );
return ;
}
temp.next = top;
top = temp;
Console.WriteLine(val + " pushed into stack successfully !" );
}
public bool isEmpty()
{
return top == null ;
}
public int peek()
{
if (!isEmpty())
return top.data;
else
Console.WriteLine( "Stack is Empty" );
Environment.Exit(1);
return -1;
}
}
class Program
{
static void Main( string [] args)
{
Stack st = new Stack();
st.push(1);
Console.WriteLine( "Peek element of stack: " + st.peek() + "\n" );
}
}
|
Javascript
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
class Stack {
constructor() {
this .top = null ;
}
push(val) {
let temp = new Node(val);
if ( this .top === null ) {
this .top = temp;
console.log(val + " pushed into stack successfully !" );
return ;
}
temp.next = this .top;
this .top = temp;
console.log(val + " pushed into stack successfully !" );
}
isEmpty() {
return this .top === null ;
}
peek() {
if (! this .isEmpty()) {
return this .top.data;
}
else {
console.log( "Stack is Empty" );
process.exit(1);
}
}
}
const st = new Stack();
st.push(1);
console.log( "Peek element of stack:" , st.peek());
|
Output
1 pushed into stack successfully !
Peek element of stack : 1
- Time Complexity: O(1). In linked list implementation also a single memory address is accessed. It takes constant time.
- Auxiliary Space: O(1). No extra space is utilized to access the element because only the value in the node at the top pointer is read.
4) isempty():
This operation tells us whether the stack is empty or not.
Below is the implementation of isempty() using Array :
C++
#include <bits/stdc++.h>
using namespace std;
class Stack {
public :
int stack[10];
int MAX = 10;
int top;
Stack() { top = -1; }
void push( int val)
{
if (top >= MAX - 1) {
cout << "Stack Overflow\n" ;
return ;
}
top++;
stack[top] = val;
cout << val
<< " pushed into stack successfully !\n" ;
}
bool isEmpty()
{
return (top < 0);
}
};
int main()
{
Stack st;
cout << st.isEmpty();
return 0;
}
|
Java
import java.io.*;
public class GFG {
static class Stack {
int stack[] = new int [ 10 ];
int MAX = 10 ;
int top;
void stack() { top = - 1 ; }
void push( int val)
{
if (top >= MAX - 1 ) {
System.out.println( "Stack Overflow" );
return ;
}
top++;
stack[top] = val;
System.out.println(
val + " pushed into stack successfully !" );
}
boolean isEmpty(){
return (top<= 0 );
}
}
public static void main(String[] args)
{
Stack st = new Stack();
System.out.println(st.isEmpty());
}
}
|
Python
class Stack:
def __init__( self ):
self .stack = [ 0 ] * 10
self . MAX = 10
self .top = - 1
def push( self , val):
if self .top > = self . MAX - 1 :
print ( "Stack Overflow" )
return
self .top + = 1
self .stack[ self .top] = val
print (val, "pushed into stack successfully!" )
def isEmpty( self ):
return ( self .top < 0 )
st = Stack()
print (st.isEmpty())
|
C#
using System;
public class GFG {
class Stack {
int [] stack = new int [10];
int MAX = 10;
int top;
public Stack() { top = -1; }
public void push( int val)
{
if (top >= MAX - 1) {
Console.WriteLine( "Stack Overflow" );
return ;
}
top++;
stack[top] = val;
Console.WriteLine(
val + " pushed into stack successfully !" );
}
public int isEmpty() { return (top <= 0) ? 1 : 0; }
}
static public void Main()
{
Stack st = new Stack();
Console.WriteLine(st.isEmpty());
}
}
|
Javascript
class Stack {
constructor() {
this .stack = [];
this .MAX = 10;
this .top = -1;
}
push(val) {
if ( this .top >= this .MAX - 1) {
console.log( "Stack Overflow" );
return ;
}
this .top++;
this .stack[ this .top] = val;
console.log(val, " pushed into stack successfully !" );
}
isEmpty() {
return ( this .top < 0);
}
};
let st = new Stack();
console.log(st.isEmpty());
|
- Time Complexity: O(1), It only performs an arithmetic operation to check if the stack is empty or not.
- Auxiliary Space: O(1), It requires no extra space.
Below is the implementation of isempty() using Linked List :
C++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int data;
Node* next;
Node( int val)
{
data = val;
next = NULL;
}
};
class Stack {
public :
Node* top;
Stack() { top = NULL; }
void push( int val)
{
Node* temp = new Node(val);
if (!top) {
top = temp;
cout << val
<< " pushed into stack successfully !\n" ;
return ;
}
temp->next = top;
top = temp;
cout << val
<< " pushed into stack successfully !\n" ;
}
bool isEmpty()
{
return top == NULL;
}
};
int main()
{
Stack st;
cout << st.isEmpty();
return 0;
}
|
Java
import java.util.EmptyStackException;
class Node {
public int data;
public Node next;
public Node( int val) {
data = val;
next = null ;
}
}
class Stack {
private Node top;
public Stack() {
top = null ;
}
public void push( int val) {
Node temp = new Node(val);
if (top == null ) {
top = temp;
System.out.println(val + " pushed into stack successfully !" );
return ;
}
temp.next = top;
top = temp;
System.out.println(val + " pushed into stack successfully !" );
}
public boolean isEmpty() {
return top == null ;
}
}
public class Main {
public static void main(String[] args) {
Stack st = new Stack();
System.out.println(st.isEmpty());
}
}
|
Python3
class Node:
def __init__( self , val):
self .data = val
self . next = None
class Stack:
def __init__( self ):
self .top = None
def push( self , val):
temp = Node(val)
if not self .top:
self .top = temp
print (val, "pushed into stack successfully!" )
return
temp. next = self .top
self .top = temp
print (val, "pushed into stack successfully!" )
def is_empty( self ):
return self .top = = None
st = Stack()
print (st.is_empty())
|
C#
using System;
class Node
{
public int data;
public Node next;
public Node( int val)
{
data = val;
next = null ;
}
}
class Stack
{
private Node top;
public Stack()
{
top = null ;
}
public void Push( int val)
{
Node temp = new Node(val);
if (top == null )
{
top = temp;
Console.WriteLine(val + " pushed into stack successfully!" );
return ;
}
temp.next = top;
top = temp;
Console.WriteLine(val + " pushed into stack successfully!" );
}
public bool IsEmpty()
{
return top == null ;
}
}
class Program
{
static void Main( string [] args)
{
Stack st = new Stack();
if (st.IsEmpty()) Console.WriteLine(1);
else Console.WriteLine(0);
}
}
|
Javascript
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
class Stack {
constructor() {
this .top = null ;
}
push(val) {
let temp = new Node(val);
if (! this .top) {
this .top = temp;
console.log(`${val} pushed into stack successfully!`);
return ;
}
temp.next = this .top;
this .top = temp;
console.log(`${val} pushed into stack successfully!`);
}
isEmpty() {
return this .top === null ;
}
}
let st = new Stack();
console.log(st.isEmpty());
|
- Time Complexity: O(1), It checks if the pointer of the top pointer is Null or not. This operation takes constant time.
- Auxiliary Space: O(1), No extra space is required.
5) size():
This operation returns the current size of the stack.
Below is the implementation of size() using Array:
C++
#include <bits/stdc++.h>
using namespace std;
class Stack {
public :
int stack[10];
int MAX = 10;
int top;
Stack() { top = -1; }
void push( int val)
{
if (top >= MAX - 1) {
cout << "Stack Overflow\n" ;
return ;
}
top++;
stack[top] = val;
cout << val
<< " pushed into stack successfully !\n" ;
}
int size() { return top + 1; }
};
int main()
{
Stack st;
st.push(1);
st.push(2);
cout << "The size of the stack is " << st.size()
<< endl;
return 0;
}
|
Java
import java.util.*;
class Stack {
int [] stack;
int MAX = 10 ;
int top;
Stack()
{
top = - 1 ;
stack = new int [MAX];
}
void push( int val)
{
if (top >= MAX - 1 ) {
System.out.println( "Stack Overflow" );
return ;
}
top++;
stack[top] = val;
System.out.println(
val + " pushed into stack successfully!" );
}
int size() { return top + 1 ; }
}
public class Main {
public static void main(String[] args)
{
Stack st = new Stack();
st.push( 1 );
st.push( 2 );
System.out.println( "The size of the stack is "
+ st.size());
}
}
|
Python3
class Stack:
stack = [ 0 ] * 10
MAX = 10
top = - 1
def push( self , val):
if self .top > = self . MAX - 1 :
print ( "Stack Overflow" )
return
self .top + = 1
self .stack[ self .top] = val
print (f "{val} pushed into stack successfully !" )
def size( self ):
return self .top + 1
st = Stack()
st.push( 1 )
st.push( 2 )
print (f "The size of the stack is {st.size()}" )
|
C#
using System;
public class Stack
{
int [] stack;
int MAX = 10;
int top;
public Stack()
{
top = -1;
stack = new int [MAX];
}
public void push( int val)
{
if (top >= MAX - 1)
{
Console.WriteLine( "Stack Overflow" );
return ;
}
top++;
stack[top] = val;
Console.WriteLine($ "{val} pushed into stack successfully!" );
}
public int size()
{
return top + 1;
}
}
public class GFG
{
public static void Main()
{
Stack st = new Stack();
st.push(1);
st.push(2);
Console.WriteLine($ "The size of the stack is {st.size()}" );
}
}
|
Javascript
class Stack {
constructor() {
this .stack = [];
this .MAX = 10;
this .top = -1;
}
push(val) {
if ( this .top >= this .MAX - 1) {
console.log( "Stack Overflow" );
return ;
}
this .top++;
this .stack[ this .top] = val;
console.log(val, " pushed into stack successfully !" );
}
size() { return this .top + 1; }
};
let st = new Stack;
st.push(1);
st.push(2);
console.log( "The size of the stack is " , st.size());
return 0;
|
Output
1 pushed into stack successfully !
2 pushed into stack successfully !
The size of the stack is 2
- Time Complexity: O(1), because this operation just performs a basic arithmetic operation.
- Auxiliary Space: O(1) NO extra space is required to calculate the value of the top pointer.
Below is the implementation of size() using Linked List:
C++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int data;
Node* next;
Node( int val)
{
data = val;
next = NULL;
}
};
class Stack {
public :
Node* top;
Node* head;
int sizeOfStack;
Stack()
{
head = NULL;
top = NULL;
sizeOfStack = 0;
}
void push( int val)
{
Node* temp = new Node(val);
sizeOfStack += 1;
if (!top) {
top = temp;
return ;
}
temp->next = top;
top = temp;
}
int size() { return sizeOfStack; }
};
int main()
{
Stack st;
st.push(1);
st.push(3);
st.push(4);
cout << "Size of stack : " << st.size();
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class Node {
public int data;
public Node next;
public Node( int val)
{
data = val;
next = null ;
}
}
class Stack {
public Node top;
public Node head;
public int sizeOfStack;
public Stack()
{
head = null ;
top = null ;
sizeOfStack = 0 ;
}
public void push( int val)
{
Node temp = new Node(val);
sizeOfStack += 1 ;
if (top == null ) {
top = temp;
return ;
}
temp.next = top;
top = temp;
}
public int size() { return sizeOfStack; }
}
class GFG {
public static void main(String[] args)
{
Stack st = new Stack();
st.push( 1 );
st.push( 3 );
st.push( 4 );
System.out.println( "Size of stack : " + st.size());
}
}
|
Python3
class Node:
def __init__( self , val):
self .data = val
self . next = None
class Stack:
def __init__( self ):
self .head = None
self .top = None
self .sizeOfStack = 0
def push( self , val):
temp = Node(val)
self .sizeOfStack + = 1
if not self .top:
self .top = temp
return
temp. next = self .top
self .top = temp
def size( self ):
return self .sizeOfStack
st = Stack()
st.push( 1 )
st.push( 3 )
st.push( 4 )
print (f "Size of stack : {st.size()}" )
|
C#
using System;
public class Node {
public int data;
public Node next;
public Node( int val)
{
data = val;
next = null ;
}
}
public class Stack {
public Node top;
public Node head;
public int sizeOfStack;
public Stack()
{
head = null ;
top = null ;
sizeOfStack = 0;
}
public void Push( int val)
{
Node temp = new Node(val);
sizeOfStack += 1;
if (top == null ) {
top = temp;
return ;
}
temp.next = top;
top = temp;
}
public int Size() { return sizeOfStack; }
static public void Main()
{
Stack st = new Stack();
st.Push(1);
st.Push(3);
st.Push(4);
Console.WriteLine( "Size of stack: " + st.Size());
}
}
|
Javascript
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
class Stack {
constructor() {
this .head = null ;
this .top = null ;
this .sizeOfStack = 0;
}
push(val) {
const temp = new Node(val);
this .sizeOfStack += 1;
if (! this .top) {
this .top = temp;
return ;
}
temp.next = this .top;
this .top = temp;
}
size() {
return this .sizeOfStack;
}
}
const st = new Stack();
st.push(1);
st.push(3);
st.push(4);
console.log( "Size of stack: " , st.size());
|
- Time Complexity: O(1), because the size is calculated and updated every time a push or pop operation is performed and is just returned in this function.
- Auxiliary Space: O(1), NO extra space is required to calculate the size of the stack.