Given an array of N distinct elements where elements are between 1 and N both inclusive, check if it is stack-sortable or not. An array A[] is said to be stack sortable if it can be stored in another array B[], using a temporary stack S. The operations that are allowed on array are:
- Remove the starting element of array A[] and push it into the stack.
- Remove the top element of the stack S and append it to the end of array B.
If all the element of A[] can be moved to B[] by performing these operations such that array B is sorted in ascending order, then array A[] is stack sortable.
Examples:
Input : A[] = { 3, 2, 1 } Output : YES Explanation : Step 1: Remove the starting element of array A[] and push it in the stack S. ( Operation 1) That makes A[] = { 2, 1 } ; Stack S = { 3 } Step 2: Operation 1 That makes A[] = { 1 } Stack S = { 3, 2 } Step 3: Operation 1 That makes A[] = {} Stack S = { 3, 2, 1 } Step 4: Operation 2 That makes Stack S = { 3, 2 } B[] = { 1 } Step 5: Operation 2 That makes Stack S = { 3 } B[] = { 1, 2 } Step 6: Operation 2 That makes Stack S = {} B[] = { 1, 2, 3 } Input : A[] = { 2, 3, 1} Output : NO
Given, array A[] is a permutation of [1, …, N], so let us suppose the initially B[] = {0}. Now we can observe that:
- We can only push an element in the stack S if the stack is empty or the current element is less than the top of the stack.
- We can only pop from the stack only if the top of the stack is
as the array B[] will contain {1, 2, 3, 4, …, n}.
If we are not able to push the starting element of the array A[], then the given array is Not Stack Sortable. Below is the implementation of above idea:
// C++ implementation of above approach. #include <bits/stdc++.h> using namespace std;
// Function to check if A[] is // Stack Sortable or Not. bool check( int A[], int N)
{ // Stack S
stack< int > S;
// Pointer to the end value of array B.
int B_end = 0;
// Traversing each element of A[] from starting
// Checking if there is a valid operation
// that can be performed.
for ( int i = 0; i < N; i++)
{
// If the stack is not empty
if (!S.empty())
{
// Top of the Stack.
int top = S.top();
// If the top of the stack is
// Equal to B_end+1, we will pop it
// And increment B_end by 1.
while (top == B_end + 1)
{
// if current top is equal to
// B_end+1, we will increment
// B_end to B_end+1
B_end = B_end + 1;
// Pop the top element.
S.pop();
// If the stack is empty We cannot
// further perform this operation.
// Therefore break
if (S.empty())
{
break ;
}
// Current Top
top = S.top();
}
// If stack is empty
// Push the Current element
if (S.empty()) {
S.push(A[i]);
}
else
{
top = S.top();
// If the Current element of the array A[]
// if smaller than the top of the stack
// We can push it in the Stack.
if (A[i] < top)
{
S.push(A[i]);
}
// Else We cannot sort the array
// Using any valid operations.
else
{
// Not Stack Sortable
return false ;
}
}
}
else
{
// If the stack is empty push the current
// element in the stack.
S.push(A[i]);
}
}
// Stack Sortable
return true ;
} // Driver's Code int main()
{ int A[] = { 4, 1, 2, 3 };
int N = sizeof (A) / sizeof (A[0]);
check(A, N)? cout<< "YES" : cout<< "NO" ;
return 0;
} |
// Java implementation of above approach. import java.util.Stack;
class GFG {
// Function to check if A[] is // Stack Sortable or Not. static boolean check( int A[], int N) {
// Stack S
Stack<Integer> S = new Stack<Integer>();
// Pointer to the end value of array B.
int B_end = 0 ;
// Traversing each element of A[] from starting
// Checking if there is a valid operation
// that can be performed.
for ( int i = 0 ; i < N; i++) {
// If the stack is not empty
if (!S.empty()) {
// Top of the Stack.
int top = S.peek();
// If the top of the stack is
// Equal to B_end+1, we will pop it
// And increment B_end by 1.
while (top == B_end + 1 ) {
// if current top is equal to
// B_end+1, we will increment
// B_end to B_end+1
B_end = B_end + 1 ;
// Pop the top element.
S.pop();
// If the stack is empty We cannot
// further perform this operation.
// Therefore break
if (S.empty()) {
break ;
}
// Current Top
top = S.peek();
}
// If stack is empty
// Push the Current element
if (S.empty()) {
S.push(A[i]);
} else {
top = S.peek();
// If the Current element of the array A[]
// if smaller than the top of the stack
// We can push it in the Stack.
if (A[i] < top) {
S.push(A[i]);
} // Else We cannot sort the array
// Using any valid operations.
else {
// Not Stack Sortable
return false ;
}
}
} else {
// If the stack is empty push the current
// element in the stack.
S.push(A[i]);
}
}
// Stack Sortable
return true ;
}
// Driver's Code public static void main(String[] args) {
int A[] = { 4 , 1 , 2 , 3 };
int N = A.length;
if (check(A, N)) {
System.out.println( "YES" );
} else {
System.out.println( "NO" );
}
}
} //This code is contributed by PrinciRaj1992 |
# Python implementation of above approach def check(A, N):
# Stack S
S = []
# Pointer to the end value of array B.
B_end = 0
# Traversing each element of A[] from starting
# Checking if there is a valid operation
# that can be performed.
for i in range (N):
# if Stack is not empty
if len (S) ! = 0 :
# top of the stack
top = S[ - 1 ]
# If the top of the stack is
# Equal to B_end+1, we will pop it
# And increment B_end by 1.
while top = = B_end + 1 :
# if current top is equal to
# B_end+1, we will increment
# B_end to B_end+1
B_end = B_end + 1
# Pop the top element
S.pop()
# If the stack is empty We cannot
# further perform this operation.
# Therefore break
if len (S) = = 0 :
break
# Current top
top = S[ - 1 ]
# If stack is empty
# Push the Current element
if len (S) = = 0 :
S.append(A[i])
else :
top = S[ - 1 ]
# If the Current element of the array A[]
# if smaller than the top of the stack
# We can push it in the Stack.
if A[i] < top:
S.append(A[i])
# Else We cannot sort the array
# Using any valid operations.
else :
# Not Stack Sortable
return False
else :
# If the stack is empty push the current
# element in the stack.
S.append(A[i])
return True
# Driver's Function if __name__ = = "__main__" :
A = [ 4 , 1 , 2 , 3 ]
N = len (A)
if check(A, N):
print ( "YES" )
else :
print ( "NO" )
|
using System;
using System.Collections.Generic;
class GFG
{ // Function to check if A[] is
// Stack Sortable or Not.
static bool check( int [] A, int N)
{
// Stack S
Stack< int > S = new Stack< int >();
// Pointer to the end value of array B.
var B_end = 0;
// Traversing each element of A[] from starting
// Checking if there is a valid operation
// that can be performed.
for ( int i = 0; i < N; i++)
{
// If the stack is not empty
if (S.Count != 0)
{
// Top of the Stack.
int top = S.Peek();
// If the top of the stack is
// Equal to B_end+1, we will pop it
// And increment B_end by 1.
while (top == B_end + 1)
{
// if current top is equal to
// B_end+1, we will increment
// B_end to B_end+1
B_end = B_end + 1;
// Pop the top element.
S.Pop();
// If the stack is empty We cannot
// further perform this operation.
// Therefore break
if (S.Count == 0) {
break ;
}
// Current Top
top = S.Peek();
}
// If stack is empty
// Push the Current element
if (S.Count == 0) {
S.Push(A[i]);
}
else {
top = S.Peek();
// If the Current element of the array
// A[] if smaller than the top of the
// stack We can push it in the Stack.
if (A[i] < top) {
S.Push(A[i]);
}
else
{
// Not Stack Sortable
return false ;
}
}
}
else
{
// If the stack is empty push the current
// element in the stack.
S.Push(A[i]);
}
}
// Stack Sortable
return true ;
}
// Driver's Code
public static void Main( string [] args)
{
int [] A = {4, 1, 2, 3};
int N = A.Length;
if (check(A, N)) {
Console.WriteLine( "YES" );
}
else {
Console.WriteLine( "NO" );
}
}
} // This code is contributed by aadityaburujwale. |
// JS implementation of above approach. // Function to check if A[] is // Stack Sortable or Not. function check(A, N) {
// Stack S
let S = [];
// Pointer to the end value of array B.
let B_end = 0;
// Traversing each element of A[] from starting
// Checking if there is a valid operation
// that can be performed.
for (let i = 0; i < N; i++) {
// If the stack is not empty
if (S.length != 0) {
// Top of the Stack.
let top = S[0];
// If the top of the stack is
// Equal to B_end+1, we will pop it
// And increment B_end by 1.
while (top == B_end + 1) {
// if current top is equal to
// B_end+1, we will increment
// B_end to B_end+1
B_end = B_end + 1;
// Pop the top element.
S.shift();
// If the stack is empty We cannot
// further perform this operation.
// Therefore break
if (S.length == 0) {
break ;
}
// Current Top
top = S[0];
}
// If stack is empty
// Push the Current element
if (S.length != 0) {
S.push(A[i]);
}
else {
top = S[0];
// If the Current element of the array A[]
// if smaller than the top of the stack
// We can push it in the Stack.
if (A[i] < top) {
S.push(A[i]);
}
// Else We cannot sort the array
// Using any valid operations.
else {
// Not Stack Sortable
return false ;
}
}
}
else {
// If the stack is empty push the current
// element in the stack.
S.push(A[i]);
}
}
// Stack Sortable
return true ;
} // Driver's Code let A = [4, 1, 2, 3]; let N = A.length; check(A, N) ? console.log( "YES" ) : console.log( "NO" );
// This code is contributed by adityamaharshi21 |
Output:
YES
Time Complexity: O(N)
Auxiliary Space: O(N) because using stack