Stack is a linear data structure that works in a model of LIFO ( last in first out ). In which, the element pushed at last will be deleted at first.
Insertion and deletion will happen on the same end. A real-life example of a stack would be a stack of books, a stack of plates, etc. The Insertion deletion diagram will look like this :
Overload ‘==’ operator to check equality of size:
Approach: The task for overloading ‘==’ operator can be performed as shown below:
- Initialize two stacks stk1 and stk2 of size N and check if size is equal or not.
- Then Implement a friend method out of class because.
- In the overloaded function for the operator, check if the size of stack1 is equal to stack2 then return true else return false.
Below is the implementation of the above approach.
#include <bits/stdc++.h> using namespace std;
class Stack {
// Properties of stack
int * stk;
int length;
int size;
public :
// One argument constructor of stack .
Stack( int size)
{
this ->size = size;
this ->length = 0;
this ->stk = new int [size];
}
// Getter method of stack
int getSize() { return this ->size; }
// Push method of stack which push data at end
void push( int val)
{
if (length < size)
stk[length++] = val;
else
cout << "\nstack is full\n" ;
}
// Friend method declaration for
// == operator overloading
friend bool operator==(Stack&, Stack&);
}; // As friend method is not the part of stack class, // so we are implementing it outside. bool operator==(Stack& stk1, Stack& stk2)
{ // If size of stk1 is equal to size of stk2,
// then return true else false;
return (stk1.getSize() == stk2.getSize());
} // Driver code int main()
{ Stack stk1(10), stk2(10);
if (stk1 == stk2) {
cout << "Both stk1 and stk2 are equal (size).\n" ;
}
else {
cout << "stk1 and stk2 are not equal (size).\n" ;
}
return 0;
} |
import java.util.*;
class Stack {
// Properties of stack
private int [] stk;
private int length;
private int size;
// One argument constructor of stack .
public Stack( int size) {
this .size = size;
this .length = 0 ;
this .stk = new int [size];
}
// Getter method of stack
public int getSize() {
return this .size;
}
// Push method of stack which push data at end
public void push( int val) {
if (length < size)
stk[length++] = val;
else
System.out.println( "\nstack is full\n" );
}
// Friend method declaration for
// == operator overloading
public static boolean equals(Stack stk1, Stack stk2) {
// If size of stk1 is equal to size of stk2,
// then return true else false;
return (stk1.getSize() == stk2.getSize());
}
} // Driver code public class Main {
public static void main(String[] args) {
Stack stk1 = new Stack( 10 );
Stack stk2 = new Stack( 10 );
if (Stack.equals(stk1, stk2)) {
System.out.println( "Both stk1 and stk2 are equal (size)." );
} else {
System.out.println( "stk1 and stk2 are not equal (size)." );
}
}
} |
class Stack:
# Constructor
def __init__( self , size):
self .size = size
self .length = 0
self .stk = [ 0 ] * size
# Getter method for size
def getSize( self ):
return self .size
# Method for pushing element to the stack
def push( self , val):
if self .length < self .size:
self .stk[ self .length] = val
self .length + = 1
else :
print ( "stack is full" )
# Overloading == operator
def __eq__( self , other):
# If size of self is equal to size of other, return True, else False
return self .getSize() = = other.getSize()
# Main function def main():
stk1 = Stack( 10 )
stk2 = Stack( 10 )
if stk1 = = stk2:
print ( "Both stk1 and stk2 are equal (size)." )
else :
print ( "stk1 and stk2 are not equal (size)." )
if __name__ = = '__main__' :
main()
# This code is contributed by Vikram_Shirsat |
using System;
public class Stack
{ private int size;
private int length;
private int [] stk;
// Constructor
public Stack( int size)
{
this .size = size;
this .length = 0;
this .stk = new int [size];
}
// Getter method for size
public int GetSize()
{
return size;
}
// Method for pushing element to the stack
public void Push( int val)
{
if (length < size)
{
stk[length] = val;
length++;
}
else
{
Console.WriteLine( "stack is full" );
}
}
// Overloading == operator
public static bool operator ==(Stack s1, Stack s2)
{
// If size of s1 is equal to size of s2, return True, else False
return s1.GetSize() == s2.GetSize();
}
public static bool operator !=(Stack s1, Stack s2)
{
return !(s1 == s2);
}
} public class Program
{ public static void Main()
{
Stack stk1 = new Stack(10);
Stack stk2 = new Stack(10);
if (stk1 == stk2)
{
Console.WriteLine( "Both stk1 and stk2 are equal (size)." );
}
else
{
Console.WriteLine( "stk1 and stk2 are not equal (size)." );
}
}
} |
class Stack { constructor(size) {
// Properties of stack
this .stk = new Array(size);
this .length = 0;
this .size = size;
}
// Getter method of stack
getSize() {
return this .size;
}
// Push method of stack which push data at end
push(val) {
if ( this .length < this .size) {
this .stk[ this .length++] = val;
} else {
console.log( "\nstack is full\n" );
}
}
// Friend method declaration for
// == operator overloading
static isEqual(stk1, stk2) {
// If size of stk1 is equal to size of stk2,
// then return true else false;
return stk1.getSize() === stk2.getSize();
}
} // Driver code const stk1 = new Stack(10);
const stk2 = new Stack(10);
if (Stack.isEqual(stk1, stk2)) {
console.log( "Both stk1 and stk2 are equal (size).\n" );
} else {
console.log( "stk1 and stk2 are not equal (size).\n" );
} |
Both stk1 and stk2 are equal (size).
Time Complexity : O(1), because all the operations performed are basic stack operations that take a constant amount of time, regardless of the input size.
Auxiliary Space : O(N), where N is the maximum size of the stack.
Overload ‘==’ operator for checking if elements of both stacks are equal:
- In this case in the overloaded function for == operator:
- If both stacks don’t have the same size, then return false.
- Check each element of both stacks and if both the stacks have the same elements then it should return true else false.
- To check that, run a loop till both are empty and compare the top elements.
Below is the implementation of the above approach.
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
class Stack {
// Properties of stack
int * stk;
int length;
int size;
public :
// One argument constructor of stack
Stack( int size)
{
this ->size = size;
this ->length = 0;
this ->stk = new int [size];
}
// Getter method of stack
int getSize() { return this ->size; }
// Return the number of element present in stack
int getLength() { return this ->length; }
// Return the iterator of first element
int * begin() { return this ->stk; }
// Push method of stack which push data at end
void push( int val)
{
if (length < size)
stk[length++] = val;
else
cout << "\nstack is full\n" ;
}
// Friend method declaration for
// == operator overloading
friend bool operator==(Stack&, Stack&);
}; // As friend method is not the part of stack class, // so we are implementing it outside. bool operator==(Stack& stk1, Stack& stk2)
{ // If size of stk1 is equal to size of stk2,
// then return true else false;
int lenghtOfStack_1 = stk1.getLength();
int lenghtOfStack_2 = stk2.getLength();
// If length of stk1 is not equal to stk2
// means both stacks have different number
// of elements, for that return false;
if (lenghtOfStack_1 != lenghtOfStack_2) {
return false ;
}
// As both the stack have same length,
// then we can use any one of them
for ( int i = 0; i < lenghtOfStack_1; i++) {
// Here, we are checking if any time stk1 value
// is not equal to stk2 value. return false.
if (stk1.begin()[i] != stk2.begin()[i]) {
return false ;
}
}
// If above loop does not return false value,
// means, both the stacks have same elements
// so, we are returning true here.
return true ;
} // Driver code int main()
{ Stack stk1(10), stk2(10);
// Pushing elements into the stacks
for ( int i = 0; i < 5; i++) {
stk1.push(i);
stk2.push(i);
}
// Checking if both stacks are equal are not.
if (stk1 == stk2) {
cout << "Both stk1 and stk2 are equal.\n" ;
}
else {
cout << "stk1 and stk2 are not equal.\n" ;
}
return 0;
} |
import java.util.Arrays;
class Stack {
// Properties of stack
private int [] stk;
private int length;
private int size;
// One argument constructor of stack
Stack( int size) {
this .size = size;
this .length = 0 ;
this .stk = new int [size];
}
// Getter method of stack
int getSize() {
return this .size;
}
// Return the number of element present in stack
int getLength() {
return this .length;
}
// Return the iterator of first element
int [] begin() {
return this .stk;
}
// Push method of stack which push data at end
void push( int val) {
if (length < size)
stk[length++] = val;
else
System.out.println( "\nstack is full\n" );
}
// Overriding the equals() method
@Override
public boolean equals(Object obj) {
if (obj == this ) {
return true ;
}
if (!(obj instanceof Stack)) {
return false ;
}
Stack otherStack = (Stack) obj;
// If size of current stack is not equal to size of other stack,
// then return false;
if ( this .length != otherStack.length) {
return false ;
}
// As both the stacks have same length,
// then we can use any one of them
for ( int i = 0 ; i < this .length; i++) {
// Here, we are checking if any time current stack value
// is not equal to other stack value. return false.
if ( this .stk[i] != otherStack.stk[i]) {
return false ;
}
}
// If above loop does not return false value,
// means, both the stacks have same elements
// so, we are returning true here.
return true ;
}
} // Driver code public class Main {
public static void main(String[] args) {
Stack stk1 = new Stack( 10 );
Stack stk2 = new Stack( 10 );
// Pushing elements into the stacks
for ( int i = 0 ; i < 5 ; i++) {
stk1.push(i);
stk2.push(i);
}
// Checking if both stacks are equal are not.
if (stk1.equals(stk2)) {
System.out.println( "Both stk1 and stk2 are equal." );
} else {
System.out.println( "stk1 and stk2 are not equal." );
}
}
} |
# Python equivalent of the given code class Stack:
# Properties of stack
stk = []
length = 0
size = 0
# One argument constructor of stack
def __init__( self , size):
self .size = size
self .length = 0
self .stk = [ 0 ] * size
# Getter method of stack
def getSize( self ):
return self .size
# Return the number of element present in stack
def getLength( self ):
return self .length
# Push method of stack which push data at end
def push( self , val):
if self .length < self .size:
self .stk[ self .length] = val
self .length + = 1
else :
print ( "stack is full" )
# As friend method is not the part of stack class,
# so we are implementing it outside.
def __eq__(stk1, stk2):
# If size of stk1 is equal to size of stk2,
# then return true else false;
lenghtOfStack_1 = stk1.getLength()
lenghtOfStack_2 = stk2.getLength()
# If length of stk1 is not equal to stk2
# means both stacks have different number
# of elements, for that return false;
if lenghtOfStack_1 ! = lenghtOfStack_2:
return False
# As both the stack have same length,
# then we can use any one of them
for i in range (lenghtOfStack_1):
# Here, we are checking if any time stk1 value
# is not equal to stk2 value. return false.
if stk1.stk[i] ! = stk2.stk[i]:
return False
# If above loop does not return false value,
# means, both the stacks have same elements
# so, we are returning true here.
return True
# Driver code if __name__ = = "__main__" :
stk1 = Stack( 10 )
stk2 = Stack( 10 )
# Pushing elements into the stacks
for i in range ( 5 ):
stk1.push(i)
stk2.push(i)
# Checking if both stacks are equal are not.
if stk1 = = stk2:
print ( "Both stk1 and stk2 are equal." )
else :
print ( "stk1 and stk2 are not equal." )
# This code is contributed by Vikram_Shirsat |
// C# code to implement the approach using System;
class Stack {
// Properties of stack
private int [] stk;
private int length;
private int size;
// One argument constructor of stack
public Stack( int size)
{
this .size = size;
this .length = 0;
this .stk = new int [size];
}
// Getter method of stack
public int GetSize() { return this .size; }
// Return the number of element present in stack
public int GetLength() { return this .length; }
// Return the iterator of first element
public int [] Begin() { return this .stk; }
// Push method of stack which push data at end
public void Push( int val)
{
if (length < size) {
stk[length++] = val;
}
else {
Console.WriteLine( "\nstack is full\n" );
}
}
// Friend method declaration for
// == operator overloading
public static bool operator == (Stack stk1, Stack stk2)
{
// If size of stk1 is equal to size of stk2,
// then return true else false;
int lengthOfStack_1 = stk1.GetLength();
int lengthOfStack_2 = stk2.GetLength();
// If length of stk1 is not equal to stk2
// means both stacks have different number
// of elements, for that return false;
if (lengthOfStack_1 != lengthOfStack_2) {
return false ;
}
// As both the stack have same length,
// then we can use any one of them
for ( int i = 0; i < lengthOfStack_1; i++) {
// Here, we are checking if any time stk1 value
// is not equal to stk2 value. return false.
if (stk1.Begin()[i] != stk2.Begin()[i]) {
return false ;
}
}
// If above loop does not return false value,
// means, both the stacks have same elements
// so, we are returning true here.
return true ;
}
public static bool operator != (Stack stk1, Stack stk2)
{
return !(stk1 == stk2);
}
} // Driver code class Program {
static void Main( string [] args)
{
Stack stk1 = new Stack(10);
Stack stk2 = new Stack(10);
// Pushing elements into the stacks
for ( int i = 0; i < 5; i++) {
stk1.Push(i);
stk2.Push(i);
}
// Checking if both stacks are equal are not.
if (stk1 == stk2) {
Console.WriteLine(
"Both stk1 and stk2 are equal." );
}
else {
Console.WriteLine(
"stk1 and stk2 are not equal." );
}
}
} |
// JavaScript code to implement the approach class Stack { // Properties of stack constructor(size) { this .stk = new Array(size);
this .length = 0;
this .size = size;
} // Getter method of stack getSize() { return this .size;
} // Return the number of element present in stack getLength() { return this .length;
} // Return the iterator of first element begin() { return this .stk;
} // Push method of stack which push data at end push(val) { if ( this .length < this .size) {
this .stk[ this .length++] = val;
} else {
console.log( "\nstack is full\n" );
} } } // Friend method declaration for // == operator overloading function equals(stk1, stk2) {
// If size of stk1 is equal to size of stk2, // then return true else false; let lengthOfStack_1 = stk1.getLength(); let lengthOfStack_2 = stk2.getLength(); // If length of stk1 is not equal to stk2 // means both stacks have different number // of elements, for that return false; if (lengthOfStack_1 !== lengthOfStack_2) {
return false ;
} // As both the stack have same length, // then we can use any one of them for (let i = 0; i < lengthOfStack_1; i++) {
// Here, we are checking if any time stk1 value // is not equal to stk2 value. return false. if (stk1.begin()[i] !== stk2.begin()[i]) {
return false ;
} } // If above loop does not return false value, // means, both the stacks have same elements // so, we are returning true here. return true ;
} // Driver code let stk1 = new Stack(10);
let stk2 = new Stack(10);
// Pushing elements into the stacks for (let i = 0; i < 5; i++) {
stk1.push(i); stk2.push(i); } // Checking if both stacks are equal are not. if (equals(stk1, stk2)) {
console.log( "Both stk1 and stk2 are equal.\n" );
} else {
console.log( "stk1 and stk2 are not equal.\n" );
} // This code is contributed by rutikbhosale |
Both stk1 and stk2 are equal.
Related Articles: