Reverse first K elements of the given Stack

Last Updated : 18 Oct, 2022

Given a stack S and an integer K, the task is to reverse the first K elements of the given stack
Examples:

Input: S = [ 1, 2, 3, 4, 5, 8, 3, 0, 9 ],  K = 4
Output: [ 4, 3, 2, 1, 5, 8, 3, 0, 9 ]
Explanation: First 4 elements of the given stack are reversed

Input: S = [ 1, 2, 3, 4, 5, 8, 3, 0, 9 ], K = 7
Output: [ 3, 8, 5, 4, 3, 2, 1, 0, 9 ]

Approach: The task can be solved using two auxiliary stacks to reverse the first K elements of the given stack. Follow the below steps to solve the problem:

• Create two stacks s1 and s2
• One by one pop all elements of the given stack and simultaneously push it into stack s1
• Now, pop k number of elements from s1 and push it in s2 simultaneously
• Pop all elements from stack s2, and push them into the given stack
• Similarly pop all elements from s1, and push them into the given stack

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to print the resultant stack` `void` `print(stack<``int``>& s)` `{` `    ``vector<``int``> v;` `    ``while` `(!s.empty()) {` `        ``int` `temp = s.top();` `        ``s.pop();` `        ``v.push_back(temp);` `    ``}`   `    ``reverse(v.begin(), v.end());` `    ``for` `(``int` `i = 0; i < v.size(); i++)` `        ``cout << ``" "` `<< v[i] << ``" "``;` `}`   `// Function to reverse and push operation` `// in the stack` `void` `stack_reverse(stack<``int``>& s, ``int` `k)` `{` `    ``stack<``int``> s1, s2;` `    ``while` `(!s.empty()) {` `        ``int` `temp = s.top();` `        ``s1.push(temp);` `        ``s.pop();` `    ``}`   `    ``for` `(``int` `i = 0; i < k; i++) {` `        ``int` `temp = s1.top();` `        ``s2.push(temp);` `        ``s1.pop();` `    ``}`   `    ``while` `(!s2.empty()) {` `        ``int` `temp = s2.top();` `        ``s.push(temp);` `        ``s2.pop();` `    ``}`   `    ``while` `(!s1.empty()) {` `        ``int` `temp = s1.top();` `        ``s.push(temp);` `        ``s1.pop();` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``stack<``int``> s;` `    ``// s = [ 1, 2, 3, 4, 5, 8, 3, 0, 9 ]` `    ``s.push(1);` `    ``s.push(2);` `    ``s.push(3);` `    ``s.push(4);` `    ``s.push(5);` `    ``s.push(8);` `    ``s.push(3);` `    ``s.push(0);` `    ``s.push(9);`   `    ``int` `k = 4;` `    ``stack_reverse(s, k);` `    ``print(s);` `}`

Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG` `{` `  ``static` `Stack s = ``new` `Stack<>();` `  `  `  ``// Function to print the resultant stack` `  ``static` `void` `print()` `  ``{` `    ``Vector v = ``new` `Vector<>();` `    ``while` `(!s.isEmpty()) {` `      ``int` `temp = s.peek();` `      ``s.pop();` `      ``v.add(temp);` `    ``}`   `    ``Collections.reverse(v);` `    ``for` `(``int` `i = ``0``; i < v.size(); i++)` `      ``System.out.print(``" "` `+  v.get(i)+ ``" "``);` `  ``}`   `  ``// Function to reverse and push operation` `  ``// in the stack` `  ``static` `void` `stack_reverse(``int` `k)` `  ``{` `    ``Stack s1 = ``new` `Stack<>(), s2 =``new` `Stack<>();` `    ``while` `(!s.isEmpty()) {` `      ``int` `temp = s.peek();` `      ``s1.add(temp);` `      ``s.pop();` `    ``}`   `    ``for` `(``int` `i = ``0``; i < k; i++) {` `      ``int` `temp = s1.peek();` `      ``s2.add(temp);` `      ``s1.pop();` `    ``}`   `    ``while` `(!s2.isEmpty()) {` `      ``int` `temp = s2.peek();` `      ``s.add(temp);` `      ``s2.pop();` `    ``}`   `    ``while` `(!s1.isEmpty()) {` `      ``int` `temp = s1.peek();` `      ``s.add(temp);` `      ``s1.pop();` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{`   `    ``// s = [ 1, 2, 3, 4, 5, 8, 3, 0, 9 ]` `    ``s.add(``1``);` `    ``s.add(``2``);` `    ``s.add(``3``);` `    ``s.add(``4``);` `    ``s.add(``5``);` `    ``s.add(``8``);` `    ``s.add(``3``);` `    ``s.add(``0``);` `    ``s.add(``9``);`   `    ``int` `k = ``4``;` `    ``stack_reverse(k);` `    ``print();` `  ``}` `}`   `// This code is contributed by gauravrajput1`

Python3

 `# python3 program for the above approach`     `# Function to print the resultant stack` `def` `print``(s):`   `    ``v ``=` `[]` `    ``while` `(``len``(s) !``=` `0``):` `        ``temp ``=` `s.pop()` `        ``v.append(temp)`   `    ``v.reverse()` `    ``for` `i ``in` `range``(``0``, ``len``(v)):` `        ``print``(f``" {v[i]} "``, end``=``"")`     `# Function to reverse and push operation` `# in the stack` `def` `stack_reverse(s, k):`   `    ``s1, s2 ``=` `[], []` `    ``while` `(``len``(s) !``=` `0``):` `        ``temp ``=` `s.pop()` `        ``s1.append(temp)`   `    ``for` `i ``in` `range``(``0``, k):` `        ``temp ``=` `s1.pop()` `        ``s2.append(temp)`   `    ``while` `(``len``(s2) !``=` `0``):` `        ``temp ``=` `s2.pop()` `        ``s.append(temp)`   `    ``while` `(``len``(s1) !``=` `0``):` `        ``temp ``=` `s1.pop()` `        ``s.append(temp)`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``s ``=` `[]` `    ``# s = [ 1, 2, 3, 4, 5, 8, 3, 0, 9 ]` `    ``s.append(``1``)` `    ``s.append(``2``)` `    ``s.append(``3``)` `    ``s.append(``4``)` `    ``s.append(``5``)` `    ``s.append(``8``)` `    ``s.append(``3``)` `    ``s.append(``0``)` `    ``s.append(``9``)`   `    ``k ``=` `4` `    ``stack_reverse(s, k)` `    ``print``(s)`   `    ``# This code is contributed by rakeshsahni`

C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG{`   `  ``//print all element of stack` `  ``static` `void` `print(Stack<``int``> stack)` `  ``{` `    ``int``[] arr = ``new` `int``[stack.Count]; ` `    ``int` `k=0;`   `    ``while` `(stack.Count !=0) ` `    ``{` `      ``int` `temp = stack.Peek();` `      ``stack.Pop();` `      ``arr[k++]=temp;` `    ``}`   `    ``Array.Reverse(arr);` `    ``for` `(``int` `i = 0; i < arr.Length; i++)` `      ``Console.Write(arr[i] + ``" "` `);`   `  ``}`     `  ``//function to reverse k element` `  ``static` `void` `stack_reverse(Stack<``int``> stack,``int` `k){`   `    ``Stack<``int``> s1 = ``new` `Stack<``int``>();` `    ``Stack<``int``> s2 =``new` `Stack<``int``>();`     `    ``while` `(stack.Count != 0) {` `      ``int` `temp = stack.Peek();` `      ``s1.Push(temp);` `      ``stack.Pop();` `    ``}`   `    ``for` `(``int` `i = 0; i < k; i++) {` `      ``int` `temp = s1.Peek();` `      ``s2.Push(temp);` `      ``s1.Pop();` `    ``}`   `    ``while` `(s2.Count != 0) {` `      ``int` `temp = s2.Peek();` `      ``stack.Push(temp);` `      ``s2.Pop();` `    ``}`   `    ``while` `(s1.Count != 0){` `      ``int` `temp = s1.Peek();` `      ``stack.Push(temp);` `      ``s1.Pop();` `    ``}` `  ``}` `  ``static` `public` `void` `Main (){`   `    ``//creating stack` `    ``Stack<``int``> stack = ``new` `Stack<``int``>();`   `    ``// Inserting elements into the Stack` `    ``stack.Push(1);` `    ``stack.Push(2);` `    ``stack.Push(3);` `    ``stack.Push(4);` `    ``stack.Push(5);` `    ``stack.Push(8);` `    ``stack.Push(3);` `    ``stack.Push(0);` `    ``stack.Push(9);`   `    ``int` `k = 4;`   `    ``// calling a function to reverse k element` `    ``stack_reverse(stack, k);` `    ``print(stack);` `  ``}` `}`   `// This code is contributed by sourabhdalal0001.`

Javascript

 ``

Output

` 4  3  2  1  5  8  3  0  9 `

Time Complexity: O(N), N is the number of elements in the stack
Auxiliary Space: O(N)

Previous
Next