# Check if the elements of stack are pairwise sorted

Given a stack of integers, write a function pairWiseSorted() that checks whether numbers in the stack are pairwise sorted or not.
The pairs must be increasing, and if the stack has an odd number of elements, the element at the top is left out of a pair. The function should retain the original stack content.

Only following standard operations are allowed on the stack.

1. push(X): Enter a element X on top of stack.
2. pop(): Removes top element of the stack.
3. empty(): To check if stack is empty.

Examples:

```Input: 4, 5, 6, 7, 8, 9
Output: Yes

Input: 4, 9, 2, 1, 10, 8
Output: No
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to use another stack.

• Create an auxiliary stack aux.
• Transfer contents of given stack to aux.
• Traverse aux. While traversing fetch top two elements and check if they are sorted or not.
• After checking put these elements back to original stack.

Below is the implementation of above approach:

## C++

 `// C++ program to check if successive ` `// pair of numbers in the stack are ` `// sorted or not ` `#include ` `using` `namespace` `std; ` ` `  `// Function to check if elements are ` `// pairwise sorted in stack ` `bool` `pairWiseConsecutive(stack<``int``> s) ` `{ ` `    ``// Transfer elements of s to aux. ` `    ``stack<``int``> aux; ` `    ``while` `(!s.empty()) { ` `        ``aux.push(s.top()); ` `        ``s.pop(); ` `    ``} ` ` `  `    ``// Traverse aux and see if ` `    ``// elements are pairwise ` `    ``// sorted or not. We also ` `    ``// need to make sure that original ` `    ``// content is retained. ` `    ``bool` `result = ``true``; ` `    ``while` `(!aux.empty()) { ` ` `  `        ``// Fetch current top two ` `        ``// elements of aux and check ` `        ``// if they are sorted. ` `        ``int` `x = aux.top(); ` `        ``aux.pop(); ` `        ``int` `y = aux.top(); ` `        ``aux.pop(); ` `        ``if` `(x > y) ` `            ``result = ``false``; ` ` `  `        ``// Push the elements to original ` `        ``// stack. ` `        ``s.push(x); ` `        ``s.push(y); ` `    ``} ` ` `  `    ``if` `(aux.size() == 1) ` `        ``s.push(aux.top()); ` ` `  `    ``return` `result; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``stack<``int``> s; ` `    ``s.push(4); ` `    ``s.push(5); ` `    ``s.push(-3); ` `    ``s.push(-2); ` `    ``s.push(10); ` `    ``s.push(11); ` `    ``s.push(5); ` `    ``s.push(6); ` `    ``// s.push(20); ` ` `  `    ``if` `(pairWiseConsecutive(s)) ` `        ``cout << ``"Yes"` `<< endl; ` `    ``else` `        ``cout << ``"No"` `<< endl; ` ` `  `    ``cout << ``"Stack content (from top)"` `            ``" after function call\n"``; ` `    ``while` `(s.empty() == ``false``) { ` `        ``cout << s.top() << ``" "``; ` `        ``s.pop(); ` `    ``} ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to check if successive  ` `// pair of numbers in the stack are  ` `// sorted or not  ` `import` `java.util.Stack; ` ` `  `class` `GFG { ` ` `  `// Function to check if elements are  ` `// pairwise sorted in stack  ` `    ``static` `boolean` `pairWiseConsecutive(Stack s) { ` `        ``// Transfer elements of s to aux.  ` `        ``Stack aux = ``new` `Stack<>(); ` `        ``while` `(!s.empty()) { ` `            ``aux.push(s.peek()); ` `            ``s.pop(); ` `        ``} ` ` `  `        ``// Traverse aux and see if  ` `        ``// elements are pairwise  ` `        ``// sorted or not. We also  ` `        ``// need to make sure that original  ` `        ``// content is retained.  ` `        ``boolean` `result = ``true``; ` `        ``while` `(!aux.empty()) { ` ` `  `            ``// Fetch current top two  ` `            ``// elements of aux and check  ` `            ``// if they are sorted.  ` `            ``int` `x = aux.peek(); ` `            ``aux.pop(); ` `            ``int` `y = aux.peek(); ` `            ``aux.pop(); ` `            ``if` `(x > y) { ` `                ``result = ``false``; ` `            ``} ` ` `  `            ``// Push the elements to original  ` `            ``// stack.  ` `            ``s.push(x); ` `            ``s.push(y); ` `        ``} ` ` `  `        ``if` `(aux.size() == ``1``) { ` `            ``s.push(aux.peek()); ` `        ``} ` ` `  `        ``return` `result; ` `    ``} ` ` `  `// Driver program  ` `    ``public` `static` `void` `main(String[] args) { ` ` `  `        ``Stack s = ``new` `Stack<>(); ` `        ``s.push(``4``); ` `        ``s.push(``5``); ` `        ``s.push(-``3``); ` `        ``s.push(-``2``); ` `        ``s.push(``10``); ` `        ``s.push(``11``); ` `        ``s.push(``5``); ` `        ``s.push(``6``); ` `        ``// s.push(20);  ` ` `  `        ``if` `(pairWiseConsecutive(s)) { ` `            ``System.out.println(``"Yes"``); ` `        ``} ``else` `{ ` `            ``System.out.println(``"No"``); ` `        ``} ` ` `  `        ``System.out.println(``"Stack content (from top)"` `                ``+ ``" after function call"``); ` `        ``while` `(s.empty() == ``false``) { ` `            ``System.out.print(s.peek() + ``" "``); ` `            ``s.pop(); ` `        ``} ` ` `  `    ``} ` ` `  `} `

## Python 3

 `# Python program to check if successive ` `# pair of numbers in the stack are ` `# sorted or not ` ` `  `# using deque as stack ` `from` `collections ``import` `deque ` ` `  `# Function to check if elements are ` `# pairwise sorted in stack ` `def` `pairWiseConsecutive(s): ` ` `  `    ``# Transfer elements of s to aux. ` `    ``aux ``=` `deque() ` `    ``while` `len``(s) > ``0``: ` `        ``aux.append(s.pop()) ` ` `  `    ``# Traverse aux and see if ` `    ``# elements are pairwise ` `    ``# sorted or not. We also ` `    ``# need to make sure that original ` `    ``# content is retained. ` `    ``result ``=` `True` `    ``while` `len``(aux) !``=` `0``: ` ` `  `        ``# Fetch current top two ` `        ``# elements of aux and check ` `        ``# if they are sorted. ` `        ``x ``=` `aux.pop() ` `        ``y ``=` `aux.pop() ` `        ``if` `x > y: ` `            ``result ``=` `False` ` `  `        ``# Push the elements to original ` `        ``# stack. ` `        ``s.append(x) ` `        ``s.append(y) ` ` `  `    ``if` `len``(aux) ``=``=` `1``: ` `        ``s.append(aux.pop()) ` ` `  `    ``return` `result ` ` `  ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``s ``=` `deque() ` `    ``s.append(``4``) ` `    ``s.append(``5``) ` `    ``s.append(``-``3``) ` `    ``s.append(``-``2``) ` `    ``s.append(``10``) ` `    ``s.append(``11``) ` `    ``s.append(``5``) ` `    ``s.append(``6``) ` ` `  `    ``if` `pairWiseConsecutive(s): ` `        ``print``(``"Yes"``) ` `    ``else``: ` `        ``print``(``"No"``) ` ` `  `    ``print``(``"Stack content (from top) after function call"``) ` `    ``while` `len``(s) > ``0``: ` `        ``print``(s.pop(), end``=``" "``) ` ` `  `# This code is contributed by ` `# sanjeev2552 `

## C#

 `// C# program to check if successive  ` `// pair of numbers in the stack are  ` `using` `System; ` `using` `System.Collections.Generic; ` `public` `class` `GFG{ ` ` `  `// Function to check if elements are  ` `// pairwise sorted in stack  ` `    ``static` `bool` `pairWiseConsecutive(Stack<``int``> s) { ` `        ``// Transfer elements of s to aux.  ` `        ``Stack<``int``> aux = ``new` `Stack<``int``>(); ` `        ``while` `(!(s.Count==0)) { ` `            ``aux.Push(s.Peek()); ` `            ``s.Pop(); ` `        ``} ` ` `  `        ``// Traverse aux and see if  ` `        ``// elements are pairwise  ` `        ``// sorted or not. We also  ` `        ``// need to make sure that original  ` `        ``// content is retained.  ` `        ``bool` `result = ``true``; ` `        ``while` `(!(aux.Count==0)) { ` ` `  `            ``// Fetch current top two  ` `            ``// elements of aux and check  ` `            ``// if they are sorted.  ` `            ``int` `x = aux.Peek(); ` `            ``aux.Pop(); ` `            ``int` `y = aux.Peek(); ` `            ``aux.Pop(); ` `            ``if` `(x > y) { ` `                ``result = ``false``; ` `            ``} ` ` `  `            ``// Push the elements to original  ` `            ``// stack.  ` `            ``s.Push(x); ` `            ``s.Push(y); ` `        ``} ` ` `  `        ``if` `(aux.Count == 1) { ` `            ``s.Push(aux.Peek()); ` `        ``} ` ` `  `        ``return` `result; ` `    ``} ` ` `  `// Driver program  ` `    ``public` `static` `void` `Main() { ` ` `  `        ``Stack<``int``> s = ``new` `Stack<``int``>(); ` `        ``s.Push(4); ` `        ``s.Push(5); ` `        ``s.Push(-3); ` `        ``s.Push(-2); ` `        ``s.Push(10); ` `        ``s.Push(11); ` `        ``s.Push(5); ` `        ``s.Push(6); ` `        ``// s.push(20);  ` ` `  `        ``if` `(pairWiseConsecutive(s)) { ` `            ``Console.WriteLine(``"Yes"``); ` `        ``} ``else` `{ ` `            ``Console.WriteLine(``"No"``); ` `        ``} ` ` `  `        ``Console.WriteLine(``"Stack content (from top)"` `                ``+ ``" after function call"``); ` `        ``while` `(!(s.Count == 0)) { ` `            ``Console.Write(s.Peek() + ``" "``); ` `            ``s.Pop(); ` `        ``} ` ` `  `    ``} ` ` `  `} `

Output:

```Yes
Stack content (from top) after function call
6 5 11 10 -2 -3 5 4
```

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : princiraj1992, sanjeev2552

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.