Related Articles
Check if two Stacks are equal or not without alteration
• Difficulty Level : Medium
• Last Updated : 03 May, 2021

Given two Stacks S1 and S2, the task is to check if both the stacks are equal or not in the same order without losing the original stacks. If both the stacks are equal, then print “Yes “. Otherwise, print “No”.

Examples:

Input: S1 = {3, 4, 2, 1}, S2 = {3, 4, 2, 1}
Output: Yes

Input: S1 = {3, 4, 6}, S2 = {7, 2, 1}
Output: No

Approach: The given problem can be solved by moving some amount of elements between the given two stacks for checking each corresponding element in the two stacks. Follow the steps below to solve the problem:

• Store the size of stack S1 and S2, in a variable N and M respectively.
• If N is not equal to M, then print “No” and return.
• Iterate over the range [1, N] and perform the following operations:
• After completing the above steps, if none of the above cases satisfy, then print “Yes“.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to push the elements from``// one stack element into another stack``void` `pushElements(stack<``int``> s1, stack<``int``> s2, ``int` `len)``{``    ``int` `i = 1;``    ``while` `(i <= len) {` `        ``// Update the stack``        ``if` `(s1.size() > 0) {``            ``s2.push(s1.top());``            ``s1.pop();``        ``}` `        ``// Increment i``        ``i++;``    ``}``}` `// Function to compare two given stacks``string compareStacks(stack<``int``> s1, stack<``int``> s2)``{``    ``// Stores the size of S1 stack``    ``int` `N = s1.size();` `    ``// Stores the size of S2 stack``    ``int` `M = s2.size();` `    ``// If N is not equal to M``    ``if` `(N != M) {``        ``return` `"No"``;``    ``}` `    ``// Traverse the range [1, N]``    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``// Push N-i elements to stack``        ``// S2 from stack S1``        ``pushElements(s1, s2, N - i);` `        ``// Stores the top value of S1``        ``int` `val = s1.top();` `        ``// Pushes the 2 * (N-i)``        ``// elements from S2 to S1``        ``pushElements(s2, s1, 2 * (N - i));` `        ``// If val is not equal``        ``// to the top of S2``        ``if` `(val != s2.top())``            ``return` `"No"``;` `        ``// Restores the stacks``        ``pushElements(s1, s2, N - i);``    ``}` `    ``// Return``    ``return` `"Yes"``;``}` `// Driver Code``int` `main()``{``    ``stack<``int``> S1, S2;` `    ``S1.push(1);``    ``S1.push(2);``    ``S1.push(4);``    ``S1.push(3);` `    ``S2.push(1);``    ``S2.push(2);``    ``S2.push(4);``    ``S2.push(3);` `    ``cout << (compareStacks(S1, S2));``}` `// This code is contributed by ukassp.`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG {` `    ``// Function to compare two given stacks``    ``static` `String compareStacks(``        ``Stack s1,``        ``Stack s2)``    ``{``        ``// Stores the size of S1 stack``        ``int` `N = s1.size();` `        ``// Stores the size of S2 stack``        ``int` `M = s2.size();` `        ``// If N is not equal to M``        ``if` `(N != M) {``            ``return` `"No"``;``        ``}` `        ``// Traverse the range [1, N]``        ``for` `(``int` `i = ``1``; i <= N; i++) {` `            ``// Push N-i elements to stack``            ``// S2 from stack S1``            ``pushElements(s1, s2, N - i);` `            ``// Stores the top value of S1``            ``int` `val = s1.peek();` `            ``// Pushes the 2 * (N-i)``            ``// elements from S2 to S1``            ``pushElements(s2, s1, ``2` `* (N - i));` `            ``// If val is not equal``            ``// to the top of S2``            ``if` `(val != s2.peek())``                ``return` `"No"``;` `            ``// Restores the stacks``            ``pushElements(s1, s2, N - i);``        ``}` `        ``// Return``        ``return` `"Yes"``;``    ``}` `    ``// Function to push the elements from``    ``// one stack element into another stack``    ``static` `void` `pushElements(``        ``Stack s1, Stack s2,``        ``int` `len)``    ``{``        ``int` `i = ``1``;``        ``while` `(i <= len) {` `            ``// Update the stack``            ``s2.push(s1.pop());` `            ``// Increment i``            ``i++;``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Stack S1 = ``new` `Stack<>();``        ``Stack S2 = ``new` `Stack<>();` `        ``S1.push(``1``);``        ``S1.push(``2``);``        ``S1.push(``4``);``        ``S1.push(``3``);` `        ``S2.push(``1``);``        ``S2.push(``2``);``        ``S2.push(``4``);``        ``S2.push(``3``);` `        ``System.out.println(``            ``compareStacks(S1, S2));``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Function to compare two given stacks``def` `compareStacks(s1, s2):``    ``# Stores the size of S1 stack``    ``N ``=` `len``(s1)` `    ``# Stores the size of S2 stack``    ``M ``=` `len``(s2)` `    ``# If N is not equal to M``    ``if` `(N !``=` `M):``        ``return` `"No"` `    ``# Traverse the range [1, N]``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``      ` `        ``# Push N-i elements to stack``        ``# S2 from stack S1``        ``pushElements(s1, s2, N ``-` `i)` `        ``# Stores the top value of S1``        ``val ``=` `s1[``-``1``]` `        ``# Pushes the 2 * (N-i)``        ``# elements from S2 to S1``        ``pushElements(s2, s1, ``2` `*` `(N ``-` `i))` `        ``# If val is not equal``        ``# to the top of S2``        ``if` `(val !``=` `s2[``-``1``]):``            ``return` `"No"` `        ``# Restores the stacks``        ``pushElements(s1, s2, N ``-` `i)` `    ``# Return``    ``return` `"Yes"` `# Function to push the elements from``# one stack element into another stack``def` `pushElements(s1, s2, ``len``):``    ``i ``=` `1``    ``while` `(i <``=` `len``):` `        ``# Update the stack``        ``s2.append(s1[``-``1``])``        ``del` `s1[``-``1``]` `        ``# Increment i``        ``i ``+``=` `1` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``S1 ``=` `[]``    ``S2 ``=` `[]` `    ``S1.append(``1``)``    ``S1.append(``2``)``    ``S1.append(``4``)``    ``S1.append(``3``)` `    ``S2.append(``1``)``    ``S2.append(``2``)``    ``S2.append(``4``)``    ``S2.append(``3``)` `    ``print``(compareStacks(S1, S2))` `# This code is contributed by mohit kumar 29.`
Output:
`Yes`

Time Complexity: O(N2)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up