ಒಂದೇ ಕ್ಯೂ ಬಳಸಿ ಸ್ಟಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್ ಫೋರ್‌ಕೈಟ್‌ಗಳು ಗೂಗಲ್ ಇನ್ಫೋಸಿಸ್ MAQ ಮೈಕ್ರೋಸಾಫ್ಟ್
ಕ್ಯೂ ಸ್ಟಾಕ್

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

“ಒಂದೇ ಕ್ಯೂ ಬಳಸಿ ಸ್ಟಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ” ಎಂಬ ಸಮಸ್ಯೆ ಕ್ಯೂ (ಎಫ್‌ಐಎಫ್‌ಒ) ದತ್ತಾಂಶ ರಚನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟಾಕ್ (ಎಲ್‌ಐಎಫ್‌ಒ) ದತ್ತಾಂಶ ರಚನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕೇಳುತ್ತದೆ.

ಇಲ್ಲಿ LIFO ಎಂದರೆ ಲಾಸ್ಟ್ ಇನ್ ಫಸ್ಟ್ Out ಟ್ ಎಂದಾದರೆ FIFO ಎಂದರೆ ಫಸ್ಟ್ ಇನ್ ಫಸ್ಟ್ .ಟ್.

ಒಂದೇ ಕ್ಯೂ ಬಳಸಿ ಸ್ಟಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ

ಉದಾಹರಣೆ

push(10)
push(20)
top()
pop()
push(30)
pop()
top()
Top : 20
Pop : 20
Pop : 30
Top : 10
push(1)
push(2)
top()
pop()
Top : 2
Pop : 2

ವಿವರಣೆ

ನಮ್ಮಲ್ಲಿ ಕ್ಯೂ ಇದೆ ಎಂದು ಭಾವಿಸೋಣ, ಮತ್ತು ಈಗ ನಾವು ಅದರಲ್ಲಿ ಅಂಶಗಳನ್ನು ಸೇರಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ ಅದರಲ್ಲಿ ಅಂಶಗಳನ್ನು ಸೇರಿಸಲು ಅಥವಾ ಸೇರಿಸಲು. ನಾವು ಕರೆಯುತ್ತೇವೆ ಪುಶ್ ಕಾರ್ಯ.

push (1) —————> ಕ್ಯೂನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ -> 1

push (2) —————> ಕ್ಯೂನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ -> 2,1

ಇದನ್ನು ಮಾಡಲು, ಈ ಹಿಂದೆ ಸರದಿಯಲ್ಲಿದ್ದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ನಾವು ತೆಗೆದುಹಾಕುತ್ತೇವೆ. ನಂತರ ನಾವು ನಮ್ಮ ಹೊಸ ಅಂಶವನ್ನು ಖಾಲಿ ಸರದಿಯಲ್ಲಿ ಸೇರಿಸುತ್ತೇವೆ. ನಂತರ ನಾವು ತೆಗೆದುಹಾಕಿದ ಅಂಶಗಳನ್ನು ಮತ್ತೆ ಅದೇ ಕ್ರಮದಲ್ಲಿ ತಳ್ಳುತ್ತೇವೆ.

ಕ್ಯೂನ ಮೇಲ್ಭಾಗ / ಮುಂಭಾಗವನ್ನು ನೋಡುವುದರಿಂದ ನಮಗೆ 2 ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತದೆ.

q.top () = 2

ಮೇಲಿನ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕೋಣ. ಆದ್ದರಿಂದ ನಾವು 2 ಅನ್ನು ಕ್ಯೂನಿಂದ ತೆಗೆದುಹಾಕುತ್ತಿದ್ದೇವೆ.

ಆದ್ದರಿಂದ ತೆಗೆದುಹಾಕಿದ ನಂತರ, ಕ್ಯೂ = 1 ರ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ.

ಏಕ ಕ್ಯೂ ಬಳಸಿ ಸ್ಟಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಲ್ಗಾರಿದಮ್

  1. A ನೊಂದಿಗೆ ವರ್ಗ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ ಕ್ಯೂ ಡೇಟಾ ರಚನೆ ಪೂರ್ಣಾಂಕ ಖಾಸಗಿ ಸದಸ್ಯರಾಗಿ ಟೈಪ್ ಮಾಡಿ. ನಾವು ಸಹ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ ಪುಶ್, ಪಾಪ್, ಟಾಪ್, ಮತ್ತು ಖಾಲಿ ಇದು ಸಾರ್ವಜನಿಕ ಸದಸ್ಯರ ಕಾರ್ಯಗಳಂತೆ.
  2. ಕಾರ್ಯವನ್ನು ಖಾಲಿ ರಚಿಸಿ (). ಕ್ಯೂ ಖಾಲಿಯಾಗಿದ್ದರೆ ನಿಜಕ್ಕೆ ಹಿಂತಿರುಗಿ.
  3. ಪುಶ್ () ಒಂದು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಒಂದು ಪೂರ್ಣಾಂಕ ವೇರಿಯೇಬಲ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಕ್ಯೂನ ಗಾತ್ರವನ್ನು ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ ಮತ್ತು ಕ್ಯೂನಲ್ಲಿ ಪೂರ್ಣಾಂಕ ವೇರಿಯಬಲ್ ಅನ್ನು ಒತ್ತಿ / ಸೇರಿಸಿ.
  4. 0 ರಿಂದ ಹಿಂದಿನ ಗಾತ್ರದ ಕ್ಯೂಗೆ ಪ್ರಯಾಣಿಸಿ. ಕ್ಯೂನ ಪ್ರಸ್ತುತ ಮುಂಭಾಗವನ್ನು ತಾನೇ ಸೇರಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ಅದನ್ನು ತೆಗೆದುಹಾಕಿ.
  5. ಸರದಿಯಲ್ಲಿ ಯಾವುದೇ ಅಂಶವಿಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಪಾಪ್ () ಕಾರ್ಯವನ್ನು ರಚಿಸಿ ನಂತರ “ಅಂಶಗಳಿಲ್ಲ” ಎಂದು ಮುದ್ರಿಸಿ -1 ಹಿಂತಿರುಗಿ. ಬೇರೆ ಪಾಪ್ / ಮೇಲಿನ / ಮುಂಭಾಗದ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕಿ.
  6. ನಾವು ಫಂಕ್ಷನ್ ಟಾಪ್ () ಅನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅದು ಕ್ಯೂನಲ್ಲಿ ಯಾವುದೇ ಅಂಶವಿಲ್ಲದಿದ್ದರೆ -1 ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಕ್ಯೂನ ಮುಂಭಾಗವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಕೋಡ್

ಒಂದೇ ಕ್ಯೂ ಬಳಸಿ ಸ್ಟಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include<bits/stdc++.h> 
using namespace std; 
  
class Stack{ 
    queue<int>q;
    
public: 
    void push(int val); 
    int pop(); 
    int top(); 
    bool empty(); 
}; 
  
void Stack::push(int val){ 
    int s = q.size(); 
  
    q.push(val); 
  
    for(int i=0; i<s; i++){ 
        q.push(q.front()); 
        q.pop(); 
    } 
} 
  
int Stack::pop(){ 
    if(q.empty()){ 
        cout<<"No elements\n";
        return -1;
    }    
    else{
        int x = q.front();
        q.pop();
        return x;
    }  
} 
  
int  Stack::top(){ 
    return (q.empty())? -1 : q.front(); 
} 
  
bool Stack::empty(){ 
    return (q.empty()); 
} 
  
int main(){ 
    Stack s;
    
    s.push(10); 
    s.push(20); 
    cout<<"Top : "<<s.top()<<endl; 
    cout<<"Pop : "<<s.pop()<<endl; 
    s.push(30); 
    cout<<"Pop : "<<s.pop()<<endl;
    cout<<"Top : "<<s.top()<<endl; 

    return 0; 
}
Top : 20
Pop : 20
Pop : 30
Top : 10

ಏಕ ಕ್ಯೂ ಬಳಸಿ ಸ್ಟಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.util.LinkedList; 
import java.util.Queue; 
  
class stack{ 
    Queue<Integer> q = new LinkedList<Integer>(); 
      
    void push(int val){ 
        int size = q.size(); 
          
        q.add(val); 
          
        for(int i=0; i<size; i++){ 
            int x = q.remove(); 
            q.add(x); 
        } 
    } 
      
    int pop(){ 
        if (q.isEmpty()){ 
            System.out.println("No elements"); 
            return -1; 
        } 
        int x = q.remove(); 
        return x; 
    } 
      
    int top(){ 
        if (q.isEmpty()) 
            return -1; 
        return q.peek(); 
    } 
      
    boolean isEmpty(){ 
        return q.isEmpty(); 
    } 
  
    public static void main(String[] args){ 
        stack s = new stack(); 
        
        s.push(10); 
        s.push(20); 
        System.out.println("Top : " + s.top()); 
        System.out.println("Pop : " + s.pop()); 
        s.push(30); 
        System.out.println("Pop : " + s.pop()); 
        System.out.println("Top : " + s.top());
        
    } 
}
Top : 20
Pop : 20
Pop : 30
Top : 10

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಪುಶ್ () ಕಾರ್ಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದೆ ಓ (ಎನ್) ಪಾಪ್ () ಮತ್ತು ಉನ್ನತ () ಕಾರ್ಯಗಳಿಗೆ ಸ್ಥಿರ ಸಮಯ ಬೇಕಾಗುತ್ತದೆ ಒ (1). ಏಕೆಂದರೆ ಒಂದು ಅಂಶವನ್ನು ತಳ್ಳಲು ನಾವು ಅದರಲ್ಲಿರುವ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ತೆಗೆದುಹಾಕುತ್ತೇವೆ ಮತ್ತು ಸೇರಿಸುತ್ತೇವೆ. ಇದು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬಹುಪದದ ಸಮಯದಲ್ಲಿ ಚಲಾಯಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಓ (ಎನ್) ಏಕೆಂದರೆ ನಾವು n ಸಂಖ್ಯೆಯ ಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಜಾಗವನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ.