रांगेतील फर्स्ट के घटक परत करत आहे  


अडचण पातळी सोपे
वारंवार विचारले काळा दगड जेपी मॉर्गन रॉबिन हूड शिंपडणे वूकर झेडस्केलेर
रांग स्टॅक

रांगेच्या समस्येचे प्रथम के घटक पूर्ववत करताना आम्ही दिले शेपूट आणि एक नंबर के, रांगेच्या मानक क्रियांचा वापर करून रांगेतील प्रथम के घटक उलट करा.

उदाहरणे  

इनपुट:
रांग = 10 -> 15 -> 31 -> 17 -> 12 -> 19 -> 2
के = 3
आउटपुट:
रांग = 31 -> 15 -> 10 -> 17 -> 12 -> 19 -> 2

इनपुट:
रांग = 12 -> 14 -> 16 -> 7 -> 9
के = 2
आउटपुट:
रांग = 14 -> 12 -> 16 -> 7 -> 9

रांगेतील फर्स्ट के घटक पूर्ववत करण्यासाठी अल्गोरिदम  

रांगेतील पहिल्या के घटकांना उलट करण्यासाठी आम्ही स्टॅक वापरू शकतो.

  1. रांगेतील प्रथम के घटक काढा आणि त्यांना स्टॅकमध्ये ढकलून द्या.
  2. स्टॅकचे सर्व घटक पॉप करा आणि रांगेच्या शेवटी दाबा.
  3. रांगेच्या पुढच्या भागातून पॉप-आउट (एन - के) घटक आणि त्यांना रांगेच्या शेवटी दाबा, जेथे रांगेत घटकांची संख्या आहे.
  4. प्रथम, रांगेतील के घटक उलट आहेत, रांगाचे घटक प्रिंट करा.

एका रांगेतील फर्स्ट के घटकांना उलट करण्यासाठी स्पष्टीकरण  

उदाहरणार्थ,
रांग = 10 -> 7 -> 4 -> 3
के = 2

पाऊल 1

रांगेतील प्रथम के घटक काढा आणि त्यांना स्टॅकमध्ये ढकलून द्या.
रांग = 10 -> 7 -> 4 -> 3 आणि स्टॅक = शून्य
Iteration 1
रांग = 7 -> 4 -> 3 आणि स्टॅक = 10
Iteration 2
रांग = 4 -> 3 आणि स्टॅक = 7 -> 10

हे सुद्धा पहा
चांगल्या जोडीची संख्या लीटकोड सोल्यूशन

पाऊल 2

स्टॅकचे सर्व घटक पॉप करा आणि रांगेच्या शेवटी दाबा.
रांग = 4 -> 3 आणि स्टॅक = 7 -> 10
Iteration 1
रांग = 4 -> 3 -> 7 आणि स्टॅक = 10
Iteration 2
रांग = 4 -> 3 -> 7 -> 10 आणि स्टॅक = शून्य

पाऊल 3

रांगेच्या पुढच्या भागातून (एन - के) घटक पॉप आउट करा आणि त्यांना रांगेच्या शेवटी दाबा
रांग = 4 -> 3 -> 7 -> 10
Iteration 1
रांग = 3 -> 7 -> 10 -> 4
Iteration 2
रांग = 7 -> 10 -> 4 -> 3

रांगेतील फर्स्ट के घटक परत करत आहे

जावा कोड

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

सी ++ कोड

#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

एका रांगेतील फर्स्ट के घटकांना उलट करण्यासाठी जटिलता विश्लेषण  

वेळ गुंतागुंत = ओ (एन + के)
स्पेस कॉम्प्लेक्सिटी = ठीक आहे) 
जेथे n ही रांगेत असलेल्या घटकांची संख्या आहे.

हे सुद्धा पहा
स्टॅकचा वापर करून रांगेत दुसर्‍या रांगेत क्रमवारी लावता येऊ शकते का ते तपासा

संदर्भ