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 :
Stack insertion And deletion or push, pop operation
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.
C++
#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 codeint 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;} |
Java
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 codepublic 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)."); } }} |
Python3
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 functiondef 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 |
C#
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)."); } }} |
Javascript
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 codeconst 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");} |
Output
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++
// 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 codeint 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;} |
Java
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 codepublic 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."); } }} |
Python3
# Python equivalent of the given codeclass 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 codeif __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#
// C# code to implement the approachusing 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 codeclass 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
// JavaScript code to implement the approachclass Stack {// Properties of stackconstructor(size) {this.stk = new Array(size);this.length = 0;this.size = size;}// Getter method of stackgetSize() {return this.size;}// Return the number of element present in stackgetLength() {return this.length;}// Return the iterator of first elementbegin() {return this.stk;}// Push method of stack which push data at endpush(val) {if (this.length < this.size) {this.stk[this.length++] = val;} else {console.log("\nstack is full\n");}}}// Friend method declaration for// == operator overloadingfunction 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 themfor (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 codelet stk1 = new Stack(10);let stk2 = new Stack(10);// Pushing elements into the stacksfor (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 |
Output
Both stk1 and stk2 are equal.
Related Articles:
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!