# Check if Queue Elements are pairwise consecutive | Set-2

• Difficulty Level : Hard
• Last Updated : 06 Aug, 2021

Given a Queue of integers. The task is to check if consecutive elements in the queue are pairwise consecutive.

Examples:

```Input: 1 2 5 6 9 10
Output: Yes

Input: 2 3 9 11 8 7
Output: No```

Approach :

• Take a variable n to store size of queue.
• Push an element to the queue which acts as marker.
• Now, If size of queue is odd, start popping a pair while n > 2. Also, while popping these pairs, check for their difference and decrease n by 2, if there difference is not equal to 1, set flag to false.
• If size of queue is even, start popping a pair while n > 1. Also, while popping these pairs, check for their difference and decrease n by 2, if their difference is not equal to 1, set flag to false.
• Finally, check flag, if it is true, it means elements in the queue are pairwise sorted, else not.

Below is the implementation of above approach:

## C++

 `// C++ program to check if successive``// pair of numbers in the queue are``// consecutive or not``#include ``using` `namespace` `std;` `// Function to check if elements are``// pairwise consecutive in queue``bool` `pairWiseConsecutive(queue<``int``> q)``{``    ``// Fetching size of queue``    ``int` `n = q.size();` `    ``// Pushing extra element to the queue``    ``// which acts as marker``    ``q.push(INT_MIN);` `    ``// Result flag``    ``bool` `result = ``true``;` `    ``// If number of elements in the``    ``// queue is odd pop elements while``    ``// its size is greater than 2.``    ``// Else, pop elements while its``    ``// size is greater than 1``    ``if` `(n % 2 != 0) {` `        ``while` `(n > 2) {``            ``int` `x = q.front();``            ``q.pop();``            ``q.push(x);``            ``n--;` `            ``int` `y = q.front();``            ``q.pop();``            ``q.push(y);``            ``n--;` `            ``if` `(``abs``(x - y) != 1) {``                ``result = ``false``;``            ``}``        ``}` `        ``// Popping the last element of queue``        ``// and pushing it again.``        ``// Also, popping the extra element``        ``// that we have pushed as marker``        ``q.push(q.front());``        ``q.pop();``        ``q.pop();``    ``}` `    ``else` `{``        ``while` `(n > 1) {``            ``int` `x = q.front();``            ``q.pop();``            ``q.push(x);``            ``n--;` `            ``int` `y = q.front();``            ``q.pop();``            ``q.push(y);``            ``n--;` `            ``if` `(``abs``(x - y) != 1) {``                ``result = ``false``;``            ``}``        ``}` `        ``// popping the extra element that``        ``// we have pushed as marker``        ``q.pop();``    ``}` `    ``return` `result;``}` `// Driver program``int` `main()``{``    ``// Pushing elements into the queue``    ``queue<``int``> q;``    ``q.push(4);``    ``q.push(5);``    ``q.push(-2);``    ``q.push(-3);``    ``q.push(11);``    ``q.push(10);``    ``q.push(5);``    ``q.push(6);``    ``q.push(8);` `    ``if` `(pairWiseConsecutive(q))``        ``cout << ``"Yes"` `<< endl;``    ``else``        ``cout << ``"No"` `<< endl;` `    ``return` `0;``}`

## Java

 `import` `java.util.LinkedList;``import` `java.util.Queue;` `// Java program to check if successive``// pair of numbers in the queue are``// consecutive or not``public` `class` `GFG {` `// Function to check if elements are``// pairwise consecutive in queue``    ``static` `boolean` `pairWiseConsecutive(Queue q) {``        ``// Fetching size of queue``        ``int` `n = q.size();` `        ``// Pushing extra element to the queue``        ``// which acts as marker``        ``q.add(Integer.MAX_VALUE);` `        ``// Result flag``        ``boolean` `result = ``true``;` `        ``// If number of elements in the``        ``// queue is odd pop elements while``        ``// its size is greater than 2.``        ``// Else, pop elements while its``        ``// size is greater than 1``        ``if` `(n % ``2` `!= ``0``) {` `            ``while` `(n > ``2``) {``                ``int` `x = q.peek();``                ``q.remove();``                ``q.add(x);``                ``n--;` `                ``int` `y = q.peek();``                ``q.remove();``                ``q.add(y);``                ``n--;` `                ``if` `(Math.abs(x - y) != ``1``) {``                    ``result = ``false``;``                ``}``            ``}` `            ``// Popping the last element of queue``            ``// and pushing it again.``            ``// Also, popping the extra element``            ``// that we have pushed as marker``            ``q.add(q.peek());``            ``q.remove();``            ``q.remove();``        ``} ``else` `{``            ``while` `(n > ``1``) {``                ``int` `x = q.peek();``                ``q.remove();``                ``q.add(x);``                ``n--;` `                ``int` `y = q.peek();``                ``q.remove();``                ``q.add(y);``                ``n--;` `                ``if` `(Math.abs(x - y) != ``1``) {``                    ``result = ``false``;``                ``}``            ``}` `            ``// popping the extra element that``            ``// we have pushed as marker``            ``q.remove();``        ``}` `        ``return` `result;``    ``}` `// Driver program``    ``static` `public` `void` `main(String[] args) {``        ``// Pushing elements into the queue``        ``Queue q = ``new` `LinkedList<>();``        ``q.add(``4``);``        ``q.add(``5``);``        ``q.add(-``2``);``        ``q.add(-``3``);``        ``q.add(``11``);``        ``q.add(``10``);``        ``q.add(``5``);``        ``q.add(``6``);``        ``q.add(``8``);` `        ``if` `(pairWiseConsecutive(q)) {``            ``System.out.println(``"Yes"``);``        ``} ``else` `{``            ``System.out.println(``"No"``);``        ``}` `    ``}``}``// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to check if successive``# pair of numbers in the queue are``# consecutive or not``import` `sys, queue` `# Function to check if elements are``# pairwise consecutive in queue``def` `pairWiseConsecutive(q):``    ` `    ``# Fetching size of queue``    ``n ``=` `q.qsize()` `    ``# Pushing extra element to the``    ``# queue which acts as marker``    ``q.put(``-``sys.maxsize);` `    ``# Result flag``    ``result ``=` `bool``(``True``)` `    ``# If number of elements in the``    ``# queue is odd pop elements while``    ``# its size is greater than 2.``    ``# Else, pop elements while its``    ``# size is greater than 1``    ``if` `(n ``%` `2` `!``=` `0``):``        ``while` `(n > ``2``):``            ``x ``=` `q.queue[``0``]``            ``q.get()``            ``q.put(x)``            ``n ``-``=` `1` `            ``y ``=` `q.queue[``0``]``            ``q.get()``            ``q.put(y)``            ``n ``-``=` `1` `            ``if` `(``abs``(x ``-` `y) !``=` `1``):``                ``result ``=` `bool``(``False``)` `        ``# Popping the last element of queue``        ``# and pushing it again.``        ``# Also, popping the extra element``        ``# that we have pushed as marker``        ``q.put(q.queue[``0``])``        ``q.get()``        ``q.get()``        ` `    ``else``:``        ``while` `(n > ``1``):``            ``x ``=` `q.queue[``0``]``            ``q.get()``            ``q.put(x)``            ``n ``-``=` `1` `            ``y ``=` `q.queue[``0``] ``            ``q.get()``            ``q.put(y)``            ``n ``-``=` `1` `            ``if` `(``abs``(x ``-` `y) !``=` `1``):``                ``result ``=` `bool``(``False``)``    ` `        ``# popping the extra element that``        ``# we have pushed as marker``        ``q.get()` `    ``return` `result` `# Driver code` `# Pushing elements into the queue``q ``=` `queue.Queue()``q.put(``4``)``q.put(``5``)``q.put(``-``2``)``q.put(``-``3``)``q.put(``11``)``q.put(``10``)``q.put(``5``)``q.put(``6``)``q.put(``8``)` `if` `(``bool``(pairWiseConsecutive(q))):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)` `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program to check if successive``// pair of numbers in the queue are``// consecutive or not``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `    ``// Function to check if elements are``    ``// pairwise consecutive in queue``    ``static` `Boolean pairWiseConsecutive(Queue<``int``> q)``    ``{``        ``// Fetching size of queue``        ``int` `n = q.Count;` `        ``// Pushing extra element to the queue``        ``// which acts as marker``        ``q.Enqueue(``int``.MaxValue);` `        ``// Result flag``        ``Boolean result = ``true``;` `        ``// If number of elements in the``        ``// queue is odd pop elements while``        ``// its size is greater than 2.``        ``// Else, pop elements while its``        ``// size is greater than 1``        ``if` `(n % 2 != 0)``        ``{``            ``while` `(n > 2)``            ``{``                ``int` `x = q.Peek();``                ``q.Dequeue();``                ``q.Enqueue(x);``                ``n--;` `                ``int` `y = q.Peek();``                ``q.Dequeue();``                ``q.Enqueue(y);``                ``n--;` `                ``if` `(Math.Abs(x - y) != 1)``                ``{``                    ``result = ``false``;``                ``}``            ``}` `            ``// Popping the last element of queue``            ``// and pushing it again.``            ``// Also, popping the extra element``            ``// that we have pushed as marker``            ``q.Enqueue(q.Peek());``            ``q.Dequeue();``            ``q.Dequeue();``        ``} ``else``        ``{``            ``while` `(n > 1)``            ``{``                ``int` `x = q.Peek();``                ``q.Dequeue();``                ``q.Enqueue(x);``                ``n--;` `                ``int` `y = q.Peek();``                ``q.Dequeue();``                ``q.Enqueue(y);``                ``n--;` `                ``if` `(Math.Abs(x - y) != 1)``                ``{``                    ``result = ``false``;``                ``}``            ``}` `            ``// popping the extra element that``            ``// we have pushed as marker``            ``q.Dequeue();``        ``}` `        ``return` `result;``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main(String[] args)``    ``{``        ``// Pushing elements into the queue``        ``Queue<``int``> q = ``new` `Queue<``int``>();``        ``q.Enqueue(4);``        ``q.Enqueue(5);``        ``q.Enqueue(-2);``        ``q.Enqueue(-3);``        ``q.Enqueue(11);``        ``q.Enqueue(10);``        ``q.Enqueue(5);``        ``q.Enqueue(6);``        ``q.Enqueue(8);` `        ``if` `(pairWiseConsecutive(q))``        ``{``            ``Console.WriteLine(``"Yes"``);``        ``}``        ``else``        ``{``            ``Console.WriteLine(``"No"``);``        ``}``    ``}``}` `// This code is contributed by Rajput-Ji`

Output:

`Yes`

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

My Personal Notes arrow_drop_up