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: YesInput: 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:
- Push the top (N – i) elements of the stack S1 to the stack S2.
- Now, store the top element of S1 stack in a variable, say val.
- Now, push the top 2 * (N – i) elements from the stack S2 to the stack S1.
- If the value of val is not equal to the top value of the stack S2, then print “No” and return.
- Otherwise, restore the stacks by pushing top (N – i) elements from the stack S1 to stack S2.
- After completing the above steps, if none of the above cases satisfy, then print “Yes“.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> 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 program for the above approach import java.util.*;
class GFG {
// Function to compare two given stacks
static String compareStacks(
Stack<Integer> s1,
Stack<Integer> 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<Integer> s1, Stack<Integer> 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<Integer> S1 = new Stack<>();
Stack<Integer> 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 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. |
// C# program for the above approach using System;
using System.Collections.Generic;
public class GFG {
// Function to compare two given stacks
static String compareStacks(
Stack< int > s1,
Stack< int > s2)
{
// Stores the size of S1 stack
int N = s1.Count;
// Stores the size of S2 stack
int M = s2.Count;
// 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< int > s1, Stack< int > 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< int > S1 = new Stack< int >();
Stack< int > S2 = new Stack< int >();
S1.Push(1);
S1.Push(2);
S1.Push(4);
S1.Push(3);
S2.Push(1);
S2.Push(2);
S2.Push(4);
S2.Push(3);
Console.WriteLine(
compareStacks(S1, S2));
}
} // This code is contributed by Amit Katiyar |
<script> // Javascript program for the above approach // Function to push the elements from // one stack element into another stack function pushElements(s1, s2, len)
{ var i = 1;
while (i <= len) {
// Update the stack
if (s1.length > 0) {
s2.push(s1[s1.length-1]);
s1.pop();
}
// Increment i
i++;
}
} // Function to compare two given stacks function compareStacks(s1, s2)
{ // Stores the size of S1 stack
var N = s1.length;
// Stores the size of S2 stack
var M = s2.length;
// If N is not equal to M
if (N != M) {
return "No" ;
}
// Traverse the range [1, N]
for ( var 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
var val = s1[s1.length-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[s2.length-1])
return "No" ;
// Restores the stacks
pushElements(s1, s2, N - i);
}
// Return
return "Yes" ;
} // Driver Code var 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); document.write(compareStacks(S1, S2)); //This code is contributed by rutvik_56. </script> |
Yes
Time Complexity: O(N2)
Auxiliary Space: O(1), since no extra space has been taken.