ಕ್ಯೂನ ಮೊದಲ ಕೆ ಅಂಶಗಳನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವುದು


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಕಪ್ಪು ಕಲ್ಲು JP ಮೋರ್ಗಾನ್ ರಾಬಿನ್ ಹುಡ್ ಸ್ಪ್ರಿಂಕ್ಲರ್ ವೂಕರ್ ZScaler
ಕ್ಯೂ ಸ್ಟಾಕ್

ಕ್ಯೂ ಸಮಸ್ಯೆಯ ಮೊದಲ ಕೆ ಅಂಶಗಳನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವಲ್ಲಿ ನಾವು a ಕ್ಯೂ ಮತ್ತು ಒಂದು ಸಂಖ್ಯೆ k, ಕ್ಯೂನ ಪ್ರಮಾಣಿತ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಯೂನ ಮೊದಲ ಕೆ ಅಂಶಗಳನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಿ.

ಉದಾಹರಣೆಗಳು

ಇನ್ಪುಟ್:
ಕ್ಯೂ = 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. ಕ್ಯೂನ ಮುಂಭಾಗದಿಂದ ಪಾಪ್- (ಟ್ (ಎನ್ - ಕೆ) ಅಂಶಗಳು ಮತ್ತು ಅವುಗಳನ್ನು ಕ್ಯೂನ ಅಂತ್ಯಕ್ಕೆ ತಳ್ಳಿರಿ, ಇಲ್ಲಿ n ಎಂಬುದು ಸರದಿಯಲ್ಲಿರುವ ಒಟ್ಟು ಅಂಶಗಳ ಸಂಖ್ಯೆ.
  4. ಮೊದಲಿಗೆ, ಕ್ಯೂನ ಕೆ ಅಂಶಗಳು ವ್ಯತಿರಿಕ್ತವಾಗಿವೆ, ಕ್ಯೂನ ಅಂಶಗಳನ್ನು ಮುದ್ರಿಸಿ.

ಕ್ಯೂನ ಮೊದಲ ಕೆ ಅಂಶಗಳನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವ ವಿವರಣೆ

ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ,
ಕ್ಯೂ = 10 -> 7 -> 4 -> 3
ಕೆ = 2

ಹಂತ 1

ಕ್ಯೂನ ಮೊದಲ ಕೆ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ಅವುಗಳನ್ನು ಸ್ಟ್ಯಾಕ್‌ಗೆ ತಳ್ಳಿರಿ.
ಕ್ಯೂ = 10 -> 7 -> 4 -> 3 ಮತ್ತು ಸ್ಟ್ಯಾಕ್ = ಶೂನ್ಯ
ಪುನರಾವರ್ತನೆ 1
ಕ್ಯೂ = 7 -> 4 -> 3 ಮತ್ತು ಸ್ಟ್ಯಾಕ್ = 10
ಪುನರಾವರ್ತನೆ 2
ಕ್ಯೂ = 4 -> 3 ಮತ್ತು ಸ್ಟ್ಯಾಕ್ = 7 -> 10

ಹಂತ 2

ಸ್ಟಾಕ್ನ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಪಾಪ್ ಮಾಡಿ ಮತ್ತು ಅವುಗಳನ್ನು ಕ್ಯೂನ ಕೊನೆಯಲ್ಲಿ ತಳ್ಳಿರಿ.
ಕ್ಯೂ = 4 -> 3 ಮತ್ತು ಸ್ಟ್ಯಾಕ್ = 7 -> 10
ಪುನರಾವರ್ತನೆ 1
ಕ್ಯೂ = 4 -> 3 -> 7 ಮತ್ತು ಸ್ಟ್ಯಾಕ್ = 10
ಪುನರಾವರ್ತನೆ 2
ಕ್ಯೂ = 4 -> 3 -> 7 -> 10 ಮತ್ತು ಸ್ಟ್ಯಾಕ್ = ಶೂನ್ಯ

ಹಂತ 3

ಕ್ಯೂನ ಮುಂಭಾಗದಿಂದ (n - k) ಅಂಶಗಳನ್ನು ಪಾಪ್ and ಟ್ ಮಾಡಿ ಮತ್ತು ಅವುಗಳನ್ನು ಕ್ಯೂನ ಅಂತ್ಯಕ್ಕೆ ತಳ್ಳಿರಿ
ಕ್ಯೂ = 4 -> 3 -> 7 -> 10
ಪುನರಾವರ್ತನೆ 1
ಕ್ಯೂ = 3 -> 7 -> 10 -> 4
ಪುನರಾವರ್ತನೆ 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 ಎಂಬುದು ಸರದಿಯಲ್ಲಿರುವ ಅಂಶಗಳ ಸಂಖ್ಯೆ.

ಉಲ್ಲೇಖಗಳು