检查堆栈元素是否成对连续-yiteyi-C++库

给定一组整数，编写一个函数pairwisecontural（），检查堆栈中的数字是否成对连续。成对的元素可以增加或减少，如果堆栈中有奇数个元素，则顶部的元素不在成对元素中。函数应保留原始堆栈内容。仅允许在堆栈上执行以下标准操作。

null

推（X）：在堆栈顶部输入元素X。
pop（）：删除堆栈的顶部元素。
empty（）：检查堆栈是否为空。

例如：

Input : stack = [4, 5, -2, -3, 11, 10, 5, 6, 20]Output : YesEach of the pairs (4, 5), (-2, -3), (11, 10) and(5, 6) consists of consecutive numbers.Input : stack = [4, 6, 6, 7, 4, 3]Output : No(4, 6) are not consecutive.

建议：请在“上解决” 实践 “首先，在讨论解决方案之前。

这个想法是使用另一个堆栈。

创建一个辅助堆栈 辅助的 .
将给定堆栈的内容转移到 辅助的 .
特拉弗斯奥克斯。在遍历时，获取最上面的两个元素，并检查它们是否连续。检查后，将这些元素放回原始堆栈。

C++

                         // C++ program to check if successive                       
                         // pair of numbers in the stack are                       
                         // consecutive or not                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Function to check if elements are                       
                         // pairwise consecutive 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                       
                                                 // consecutive or not. We also                       
                                                 // need to make sure that original                       
                                                 // content is retained.                       
                                                 bool                                     result =                                     true                                     ;                       
                                                 while                                     (aux.size() > 1) {                       
           
                                                 // Fetch current top two                       
                                                 // elements of aux and check                       
                                                 // if they are consecutive.                       
                                                 int                                     x = aux.top();                       
                                                 aux.pop();                       
                                                 int                                     y = aux.top();                       
                                                 aux.pop();                       
                                                 if                                     (                                     abs                                     (x - y) != 1)                       
                                                 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(-2);                       
                                                 s.push(-3);                       
                                                 s.push(11);                       
                                                 s.push(10);                       
                                                 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"                                     ;                       
                                                 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                       
                         // consecutive or not                       
                         import                                     java.util.*;                       
                         class                                     GfG {                       
           
                         // Function to check if elements are                       
                         // pairwise consecutive in stack                       
                         static                                     boolean                                     pairWiseConsecutive(Stack<Integer> s)                       
                         {                       
                                                 // Transfer elements of s to aux.                       
                                                 Stack<Integer> aux =                                     new                                     Stack<Integer> ();                       
                                                 while                                     (!s.isEmpty()) {                       
                                                 aux.push(s.peek());                       
                                                 s.pop();                       
                                                 }                       
           
                                                 // Traverse aux and see if                       
                                                 // elements are pairwise                       
                                                 // consecutive or not. We also                       
                                                 // need to make sure that original                       
                                                 // content is retained.                       
                                                 boolean                                     result =                                     true                                     ;                       
                                                 while                                     (aux.size() >                                     1                                     ) {                       
           
                                                 // Fetch current top two                       
                                                 // elements of aux and check                       
                                                 // if they are consecutive.                       
                                                 int                                     x = aux.peek();                       
                                                 aux.pop();                       
                                                 int                                     y = aux.peek();                       
                                                 aux.pop();                       
                                                 if                                     (Math.abs(x - y) !=                                     1                                     )                       
                                                 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<Integer> s =                                     new                                     Stack<Integer> ();                       
                                                 s.push(                                     4                                     );                       
                                                 s.push(                                     5                                     );                       
                                                 s.push(-                                     2                                     );                       
                                                 s.push(-                                     3                                     );                       
                                                 s.push(                                     11                                     );                       
                                                 s.push(                                     10                                     );                       
                                                 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.isEmpty() ==                                     false                                     )                       
                                                 {                       
                                                 System.out.print(s.peek() +                                     " "                                     );                       
                                                 s.pop();                       
                                                 }                       
           
                         }                       
                         }                       

Python3

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

C#

                         // C# program to check if successive                       
                         // pair of numbers in the stack are                       
                         // consecutive or not                       
                         using                                     System;                       
                         using                                     System.Collections.Generic;                       
           
                         class                                     GfG                       
                         {                       
           
                         // Function to check if elements are                       
                         // pairwise consecutive 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                       
                                                 // consecutive or not. We also                       
                                                 // need to make sure that original                       
                                                 // content is retained.                       
                                                 bool                                     result =                                     true                                     ;                       
                                                 while                                     (aux.Count > 1)                       
                                                 {                       
           
                                                 // Fetch current top two                       
                                                 // elements of aux and check                       
                                                 // if they are consecutive.                       
                                                 int                                     x = aux.Peek();                       
                                                 aux.Pop();                       
                                                 int                                     y = aux.Peek();                       
                                                 aux.Pop();                       
                                                 if                                     (Math.Abs(x - y) != 1)                       
                                                 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 code                       
                         public                                     static                                     void                                     Main()                       
                         {                       
                                                 Stack<                                     int                                     > s =                                     new                                     Stack<                                     int                                     > ();                       
                                                 s.Push(4);                       
                                                 s.Push(5);                       
                                                 s.Push(-2);                       
                                                 s.Push(-3);                       
                                                 s.Push(11);                       
                                                 s.Push(10);                       
                                                 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();                       
                                                 }                       
           
                         }                       
                         }                       
           
                         /* This code contributed by PrinciRaj1992 */                       

Javascript

                         <script>                       
           
                         // JavaScript program to check if successive                       
                         // pair of numbers in the stack are                       
                         // consecutive or not                       
           
                         // Function to check if elements are                       
                         // pairwise consecutive in stack                       
                         function                                     pairWiseConsecutive( s)                       
                         {                       
                                                 // Transfer elements of s to aux.                       
                                                 var                                     aux = [];                       
                                                 while                                     (s.length!=0) {                       
                                                 aux.push(s[s.length-1]);                       
                                                 s.pop();                       
                                                 }                       
           
                                                 // Traverse aux and see if                       
                                                 // elements are pairwise                       
                                                 // consecutive or not. We also                       
                                                 // need to make sure that original                       
                                                 // content is retained.                       
                                                 var                                     result =                                     true                                     ;                       
                                                 while                                     (aux.length > 1) {                       
           
                                                 // Fetch current top two                       
                                                 // elements of aux and check                       
                                                 // if they are consecutive.                       
                                                 var                                     x = aux[aux.length-1];                       
                                                 aux.pop();                       
                                                 var                                     y = aux[aux.length-1];                       
                                                 aux.pop();                       
                                                 if                                     (Math.abs(x - y) != 1)                       
                                                 result =                                     false                                     ;                       
           
                                                 // Push the elements to original                       
                                                 // stack.                       
                                                 s.push(x);                       
                                                 s.push(y);                       
                                                 }                       
           
                                                 if                                     (aux.length == 1)                       
                                                 s.push(aux[aux.length-1]);                       
           
                                                 return                                     result;                       
                         }                       
           
                         // Driver program                       
                         var                                     s = [];                       
                         s.push(4);                       
                         s.push(5);                       
                         s.push(-2);                       
                         s.push(-3);                       
                         s.push(11);                       
                         s.push(10);                       
                         s.push(5);                       
                         s.push(6);                       
                         s.push(20);                       
                         if                                     (pairWiseConsecutive(s))                       
                                                 document.write(                                     "Yes<br>"                                     );                       
                         else                       
                                                 document.write(                                     "No<br>"                                     );                       
                         document.write(                                     "Stack content (from top)"                                     +                       
                                                 " after function call<br>"                                     );                       
                         while                                     (s.length!=0)                       
                         {                       
                                                 document.write( s[s.length-1] +                                     " "                                     );                       
                                                 s.pop();                       
                         }                       
           
                         </script>                       

输出：

YesStack content (from top) after function call20 6 5 10 11 -3 -2 5 4

时间复杂性： O（n）。 辅助空间： O（n）。本文由 普拉克里蒂·古普塔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章