Skip to content
Related Articles
Open in App
Not now

Related Articles

Reverse first K elements of the given Stack

Improve Article
Save Article
  • Last Updated : 18 Oct, 2022
Improve Article
Save Article

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 <bits/stdc++.h>
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<Integer> s = new Stack<>();
   
  // Function to print the resultant stack
  static void print()
  {
    Vector<Integer> 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<Integer> 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




<script>
       // JavaScript code for the above approach
 
       // Function to print the resultant stack
       function print(s) {
           let v = [];
           while (s.length != 0) {
               let temp = s[s.length - 1];
               s.pop();
               v.push(temp);
           }
           v.reverse();
           for (let i = 0; i < v.length; i++)
               document.write(" " + v[i] + " ");
       }
 
       // Function to reverse and push operation
       // in the stack
       function stack_reverse(s, k) {
           let s1 = [], s2 = [];
           while (s.length != 0) {
               let temp = s[s.length - 1];
               s1.push(temp);
               s.pop();
           }
 
           for (let i = 0; i < k; i++) {
               let temp = s1[s1.length - 1];
               s2.push(temp);
               s1.pop();
           }
 
           while (s2.length != 0) {
               let temp = s2[s2.length - 1];
               s.push(temp);
               s2.pop();
           }
 
           while (s1.length != 0) {
               let temp = s1[s1.length - 1];
               s.push(temp);
               s1.pop();
           }
       }
 
       // Driver Code
 
       let 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);
 
       let k = 4;
       stack_reverse(s, k);
       print(s);
 
      // This code is contributed by Potta Lokesh
   </script>


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) 

 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!