एक लामको पहिलो K तत्वहरू उल्टाउँदै


कठिनाई तह सजिलो
बारम्बार सोधिन्छ BlackRock जेपी मोर्गन Robinhood स्प्रिंक्लर वूकर ZScaler
लाम थाक

लाम समस्याको पहिलो K तत्वहरू उल्टाउँदा हामीले एउटालाई दियौं लाम र संख्या k, प the्क्तिको पहिलो k तत्वहरू उल्टो गर्नुहोस्।

उदाहरण

इनपुट:
पue्क्ति = 10 -> १ - -> --१ -> १> -> १२ -> १ - -> २
k = २
उत्पादन:
पue्क्ति = 31 -> १ - -> --१ -> १> -> १२ -> १ - -> २

इनपुट:
लाम = १० -> - -> २ -> - ->।
k = २
उत्पादन:
लाम = १० -> - -> २ -> - ->।

एक पue्क्तिको पहिलो K तत्वहरू उल्टाउनको लागि एल्गोरिथ्म

लामको पहिलो के तत्वहरू रिभर्स गर्न हामी स्ट्याक प्रयोग गर्न सक्छौं।

  1. लामको पहिलो k तत्वहरू हटाउनुहोस् र त्यसलाई स्ट्याकमा धकेल्नुहोस्।
  2. स्ट्याकको सबै तत्वहरू पप गर्नुहोस् र तिनीहरूलाई लामको अन्तमा पुश गर्नुहोस्।
  3. पप-आउट (n - k) तत्वहरू लामको अगाडिबाट र तिनीहरूलाई लामको अन्तमा धकेल्नुहोस्, जहाँ n लाममा तत्वहरूको कुल संख्या हो।
  4. पहिले, लामको k तत्वहरू उल्टो छन्, लामको एन्टिमेन्टहरू प्रिन्ट गर्नुहोस्।

एक पue्क्तिको पहिलो K तत्वहरू उल्टाउनको लागि विवरण

एक उदाहरण विचार गर्नुहोस्,
लाम = १० -> - -> - -> २ 10
k = २

चरण 1

लामको पहिलो k तत्वहरू हटाउनुहोस् र त्यसलाई स्ट्याकमा धकेल्नुहोस्।
पue्क्ति = २ - -> - -> - -> १० र स्ट्याक = शून्य
Iteration १
पue्क्ति = २ - -> - -> and र स्ट्याक = १०
Iteration १
पue्क्ति = 4 -> 3 र स्ट्याक = 7 -> 10

चरण 2

स्ट्याकको सबै तत्वहरू पप गर्नुहोस् र तिनीहरूलाई लामको अन्तमा पुश गर्नुहोस्।
पue्क्ति = 4 -> 3 र स्ट्याक = 7 -> 10
Iteration १
पue्क्ति = 4 -> 3 -> 7 र स्ट्याक = 10
Iteration १
पue्क्ति = २ - -> - -> - -> १० र स्ट्याक = शून्य

चरण 3

लामको अगाडिबाट (n - k) एलिमेन्ट्स पप आउट गर्नुहोस् र तिनीहरूलाई लामको अन्तमा पुश गर्नुहोस्
लाम = १० -> - -> - -> २ 4
Iteration १
लाम = १० -> - -> - -> २ 3
Iteration १
लाम = १० -> - -> - -> २ 7

एक लामको पहिलो K तत्वहरू उल्टाउँदै

जाभा कोड

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class ReversingTheFirstKElementsOfAQueue {
    private static void reverseKElements(Queue<Integer> queue, int k) {
        if (k < 0 || k >= queue.size() || queue.isEmpty()) {
            System.out.println("Invalid Input");
            return;
        }

        int n = queue.size();

        // remove first k elements of queue and push in stack
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < k; i++) {
            int curr = queue.poll();
            stack.push(curr);
        }
        
        // Pop out elements from stack and add to the end of the queue
        while (!stack.isEmpty()) {
            int curr = stack.pop();
            queue.add(curr);
        }

        // Remove first (n - k) elements of the queue and add them to the end
        for (int i = 0; i < n - k; i++) {
            int curr = queue.poll();
            queue.add(curr);
        }

        // Print the elements of the queue
        for (Integer i : queue) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Example 1
        Queue<Integer> q1 = new LinkedList<>();
        int k1 = 3;
        q1.add(10);
        q1.add(15);
        q1.add(31);
        q1.add(17);
        q1.add(12);
        q1.add(19);
        q1.add(2);
        reverseKElements(q1, k1);

        // Example 2
        Queue<Integer> q2 = new LinkedList<>();
        int k2 = 2;
        q2.add(12);
        q2.add(14);
        q2.add(16);
        q2.add(7);
        q2.add(9);
        reverseKElements(q2, k2);
    }
}
31 15 10 17 12 19 2 
14 12 16 7 9

C ++ कोड

#include<bits/stdc++.h> 
using namespace std;

void reverseKElements(queue<int> &queue, int k) {
    if (k < 0 || k >= queue.size() || queue.empty()) {
        cout<<"Invalid Input"<<endl;
        return;
    }
    
    int n = queue.size();
    
    // remove first k elements of queue and push in stack
    stack<int> st;
    for (int i = 0; i < k; i++) {
        int curr = queue.front();
        queue.pop();
        st.push(curr);
    }
    
    // Pop out elements from stack and add to the end of the queue
    for (int i = 0; i < k; i++) {
        int curr = st.top();
        st.pop();
        queue.push(curr);
    }
    
    // Remove first (n - k) elements of the queue and add them to the end
    for (int i = 0; i < n - k; i++) {
        int curr = queue.front();
        queue.pop();
        queue.push(curr);
    }
    
    // Print the elements of the queue
    for (int i = 0; i < n; i++) {
        int curr = queue.front();
        queue.pop();
        cout<<curr<<" ";
        queue.push(curr);
    }
    cout<<endl;
}

int main() {
    // Example 1
    queue<int> q1;
    int k1 = 3;
    q1.push(10);
    q1.push(15);
    q1.push(31);
    q1.push(17);
    q1.push(12);
    q1.push(19);
    q1.push(2);
    reverseKElements(q1, k1);

    // Example 2
    queue<int> q2;
    int k2 = 2;
    q2.push(12);
    q2.push(14);
    q2.push(16);
    q2.push(7);
    q2.push(9);
    reverseKElements(q2, k2);
}
31 15 10 17 12 19 2 
14 12 16 7 9

प Que्क्तिको पहिलो K तत्वहरू उल्टाउनको लागि जटिलता विश्लेषण

समय जटिलता = O (n + k)
ठाउँ जटिलता = ठिक छ) 
जहाँ n लाममा तत्वहरूको संख्या हो।

सन्दर्भ