Invertir los primeros K elementos de una cola

Dado un entero k y una cola de enteros, necesitamos invertir el orden de los primeros k elementos de la cola, dejando los demás elementos en el mismo orden relativo.
Solo se permiten las siguientes operaciones estándar en la cola. 

  • enqueue(x) : Agrega un elemento x al final de la cola
  • dequeue() : elimina un elemento del frente de la cola
  • size() : Devuelve el número de elementos en cola.
  • front() : Encuentra el elemento frontal.

Ejemplos: 

C++

// C++ program to reverse first
// k elements of a queue.
#include <bits/stdc++.h>
using namespace std;
 
/* Function to reverse the first
   K elements of the Queue */
void reverseQueueFirstKElements(
    int k, queue<int>& Queue)
{
    if (Queue.empty() == true
        || k > Queue.size())
        return;
    if (k <= 0)
        return;
 
    stack<int> Stack;
 
    /* Push the first K elements
       into a Stack*/
    for (int i = 0; i < k; i++) {
        Stack.push(Queue.front());
        Queue.pop();
    }
 
    /* Enqueue the contents of stack
       at the back of the queue*/
    while (!Stack.empty()) {
        Queue.push(Stack.top());
        Stack.pop();
    }
 
    /* Remove the remaining elements and
       enqueue them at the end of the Queue*/
    for (int i = 0; i < Queue.size() - k; i++) {
        Queue.push(Queue.front());
        Queue.pop();
    }
}
 
/* Utility Function to print the Queue */
void Print(queue<int>& Queue)
{
    while (!Queue.empty()) {
        cout << Queue.front() << " ";
        Queue.pop();
    }
}
 
// Driver code
int main()
{
    queue<int> Queue;
    Queue.push(10);
    Queue.push(20);
    Queue.push(30);
    Queue.push(40);
    Queue.push(50);
    Queue.push(60);
    Queue.push(70);
    Queue.push(80);
    Queue.push(90);
    Queue.push(100);
 
    int k = 5;
    reverseQueueFirstKElements(k, Queue);
    Print(Queue);
}

Java

// Java program to reverse first k elements
// of a queue.
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
 
public class Reverse_k_element_queue {
 
    static Queue<Integer> queue;
 
    // Function to reverse the first
    // K elements of the Queue
    static void reverseQueueFirstKElements(int k)
    {
        if (queue.isEmpty() == true
            || k > queue.size())
            return;
        if (k <= 0)
            return;
 
        Stack<Integer> stack = new Stack<Integer>();
 
        // Push the first K elements into a Stack
        for (int i = 0; i < k; i++) {
            stack.push(queue.peek());
            queue.remove();
        }
 
        // Enqueue the contents of stack
        // at the back of the queue
        while (!stack.empty()) {
            queue.add(stack.peek());
            stack.pop();
        }
 
        // Remove the remaining elements and enqueue
        // them at the end of the Queue
        for (int i = 0; i < queue.size() - k; i++) {
            queue.add(queue.peek());
            queue.remove();
        }
    }
 
    // Utility Function to print the Queue
    static void Print()
    {
        while (!queue.isEmpty()) {
            System.out.print(queue.peek() + " ");
            queue.remove();
        }
    }
 
    // Driver code
    public static void main(String args[])
    {
        queue = new LinkedList<Integer>();
        queue.add(10);
        queue.add(20);
        queue.add(30);
        queue.add(40);
        queue.add(50);
        queue.add(60);
        queue.add(70);
        queue.add(80);
        queue.add(90);
        queue.add(100);
 
        int k = 5;
        reverseQueueFirstKElements(k);
        Print();
    }
}
// This code is contributed by Sumit Ghosh

Python3

# Python3 program to reverse first k
# elements of a queue.
from queue import Queue
 
# Function to reverse the first K
# elements of the Queue
def reverseQueueFirstKElements(k, Queue):
    if (Queue.empty() == True or
             k > Queue.qsize()):
        return
    if (k <= 0):
        return
 
    Stack = []
 
    # put the first K elements
    # into a Stack
    for i in range(k):
        Stack.append(Queue.queue[0])
        Queue.get()
 
    # Enqueue the contents of stack
    # at the back of the queue
    while (len(Stack) != 0 ):
        Queue.put(Stack[-1])
        Stack.pop()
 
    # Remove the remaining elements and
    # enqueue them at the end of the Queue
    for i in range(Queue.qsize() - k):
        Queue.put(Queue.queue[0])
        Queue.get()
 
# Utility Function to print the Queue
def Print(Queue):
    while (not Queue.empty()):
        print(Queue.queue[0], end =" ")
        Queue.get()
 
# Driver code
if __name__ == '__main__':
    Queue = Queue()
    Queue.put(10)
    Queue.put(20)
    Queue.put(30)
    Queue.put(40)
    Queue.put(50)
    Queue.put(60)
    Queue.put(70)
    Queue.put(80)
    Queue.put(90)
    Queue.put(100)
 
    k = 5
    reverseQueueFirstKElements(k, Queue)
    Print(Queue)
 
# This code is contributed by PranchalK

C#

// C# program to reverse first k elements
// of a queue.
using System;
using System.Collections.Generic;
 
class GFG {
 
    public static LinkedList<int> queue;
 
    // Function to reverse the first K
    // elements of the Queue
    public static void reverseQueueFirstKElements(int k)
    {
        if (queue.Count == 0 || k > queue.Count) {
            return;
        }
        if (k <= 0) {
            return;
        }
 
        Stack<int> stack = new Stack<int>();
 
        // Push the first K elements into a Stack
        for (int i = 0; i < k; i++) {
            stack.Push(queue.First.Value);
            queue.RemoveFirst();
        }
 
        // Enqueue the contents of stack at
        // the back of the queue
        while (stack.Count > 0) {
            queue.AddLast(stack.Peek());
            stack.Pop();
        }
 
        // Remove the remaining elements and
        // enqueue them at the end of the Queue
        for (int i = 0; i < queue.Count - k; i++) {
            queue.AddLast(queue.First.Value);<li><strong>Complexity Analysis:</strong>
<strong>Time Complexity:</strong> O(n<sup>3</sup>).
As three nested for loops are used.
<strong>Auxiliary Space :</strong>No use of any data structure for storing values-: O(1)
</li>
        queue.RemoveFirst();
        }
    }
 
    // Utility Function to print the Queue
    public static void Print()
    {
        while (queue.Count > 0) {
            Console.Write(queue.First.Value + " ");
            queue.RemoveFirst();
        }
    }
 
    // Driver code
    public static void Main(string[] args)
    {
        queue = new LinkedList<int>();
        queue.AddLast(10);
        queue.AddLast(20);
        queue.AddLast(30);
        queue.AddLast(40);
        queue.AddLast(50);
        queue.AddLast(60);
        queue.AddLast(70);
        queue.AddLast(80);
        queue.AddLast(90);
        queue.AddLast(100);
 
        int k = 5;
        reverseQueueFirstKElements(k);
        Print();
    }
}
 
// This code is contributed by Shrikant13

Javascript

<script>
 
// JavaScript program to reverse first
// k elements of a queue.
 
/* Function to reverse the first
K elements of the Queue */
function reverseQueueFirstKElements(k,Queue)
{
    if (Queue.length == 0 || k > Queue.length)
        return;
    if (k <= 0)
        return;
 
    let Stack = [];
 
    /* Push the first K elements
    into a Stack*/
    for (let i = 0; i < k; i++) {
        Stack.push(Queue.shift());
    }
 
    /* Enqueue the contents of stack
    at the back of the queue*/
    while (Stack.length > 0) {
        Queue.push(Stack.pop());
    }
 
    /* Remove the remaining elements and
    enqueue them at the end of the Queue*/
    for (let i = 0; i < Queue.length - k; i++) {
        Queue.push(Queue.shift());
    }
}
 
/* Utility Function to print the Queue */
function Print(Queue)
{
    while (Queue.length > 0) {
        document.write(Queue.shift()," ");
    }
}
 
// Driver code
 
let Queue = [];
Queue.push(10);
Queue.push(20);
Queue.push(30);
Queue.push(40);
Queue.push(50);
Queue.push(60);
Queue.push(70);
Queue.push(80);
Queue.push(90);
Queue.push(100);
 
let k = 5;
reverseQueueFirstKElements(k, Queue);
Print(Queue);
 
// This code is contributed by shinjanpatra
 
</script>

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *