सरणी

Question

का उपयोग करके एक साधारण कतार को कार्यान्वित करना मुझे सरणी और कतार और ढेर के बारे में बहुत कुछ पता नहीं है। मुझे पता है कि एक साधारण कतार कैसे कार्यान्वित करें।

#include <iostream> 
#include <queue> 

using namespace std; 

void main() 
{ 
    queue<char> queue1; 
    queue1.push('a'); 
    queue1.push('b'); 
    queue1.push('c'); 
    queue1.push('d'); 

    while(!queue1.empty()) 
    { 
     cout << queue1.front(); 
     queue1.pop(); 
     cout << endl; 
    } 

    system("pause"); 
} 

मैं सरणी का उपयोग करके एक साधारण कतार कैसे कार्यान्वित कर सकता हूं?

Answer 1

यदि आपकी कतार एक सरणी पर आधारित है, तो दक्षता के लिए, मैं एक बाध्य या "परिपत्र" कतार बनाने की अनुशंसा करता हूं, जहां कतार का अधिकतम आकार तय किया गया है, और आपके मूल रूप से एक सिर और पूंछ सूचक है जो कतार के सरणी में "पहली" और "आखिरी" स्थितियों को इंगित करता है, और जब पूंछ-सूचक (या सूचकांक मान) सरणी के अंत "अतीत" स्थिति में स्थानांतरित हो जाता है, तो यह वास्तव में शुरुआत की ओर जाता है सरणी एक सरणी के आधार पर एक असंबद्ध कतार बहुत अक्षम होगी, क्योंकि जब भी आप सरणी के अधिकतम आकार को भरते हैं, और/या जब आप पहली बार हटाते हैं तो सरणी के नीचे तत्वों को फिर से घुमाने की कोशिश करते हैं कतार का तत्व।

का उपयोग head के लिए अभिन्न प्रकार सरणी अनुक्रमित और के बजाय वास्तविक सूचक प्रकार से tail अपनी कतार में आइटम की कुल संख्या निर्धारित करने के लिए एक काउंटर, अपने को कतारबद्ध और विपंक्ति कार्यों के साथ-साथ दिखाई दे सकता है के रूप में सरल रूप में:

template<typename T> 
bool queue<T>::enqueue(const T& item) 
{ 
    if (count == array_size) 
     return false; 

    array[tail] = item; 

    tail = (tail + 1) % array_size; 
    count++; 

    return true; 
} 

template<typename T> 
bool queue<T>::dequeue(T& item) 
{ 
    if (!count) 
     return false; 

    item = array[head]; 

    head = (head + 1) % array_size; 
    count--; 

    return true; 
} 

आप इस अवधारणा को जो कुछ भी काम करना चाहते हैं, उसमें विस्तारित कर सकते हैं, यानी, अगर आप कतार के सिर तक पहुंचने और वास्तव में कतार से तत्व को हटाने के लिए एसटीएल उपयोगों जैसे अलग कार्य करेंगे।

Answer 2

नोट: गोलाकार डेटा भंडारण के रूप में एक सरणी (रैखिक डेटा संग्रहण) को अनुकरण करते समय और कतार के गुणों को बनाए रखने के दौरान, एक सेल हमेशा अप्रयुक्त होगा। इसलिए, सरणी की अधिकतम क्षमता 6 कोशिकाओं वाले सरणी के लिए 5 होगी। नीचे सी ++ कोड आत्म व्याख्यात्मक है। इसके अलावा, कतार के The Linked List Based Implementation देखें।

/*Implementation of queue with basic operation using arrays */ 

#include<iostream>   
using namespace std;   
#define MAX 6    //to accomodate a maximum of 05 elements as 1 cell pointed by tail will always be vacant 

void ENQUE(int key);  // ~insertion 
int DEQUEUE();    // ~deletion 
void TRAVERSE(); 
bool isEmpty(); 
bool isFull(); 

int Q[MAX], head=0, tail=0; /* Note: head is the side facing cashier and new person joins the queue at tail. So, from cashier point of view tail~rear and head~front. 
           Q -> [h ][][][][][][][][][][t] 
           Q -> [h,t][][][][][][][][][][] : initial configuration*/ 



int main(){ 
    int choice,val,i; 
    char ch='y'; 

    do{ 
     cout<<"1. For Enqueue \n"; 
     cout<<"2. For Dequeue \n"; 
     cout<<"3. For Traverse \nYour Option : "; 
     cin>>choice; 

     switch(choice) 
     { 
      case 1 :  // insertion 
       if(isFull()){ 
        cout<<"\nQueue Full !!!\n"; 
        break; 
       } 
       cin>>val; 
       ENQUE(val); 
       TRAVERSE(); 
       break; 

      case 2 :  //deletion 
       if(isEmpty()){ 
        cout<<"\nQueue Empty !!!\n"; 
        break; 
       } 
       cout<<"\nDeleted element from Queue : "<<DEQUEUE()<<endl; 
       TRAVERSE(); 
       break; 

      case 3 :  //traversal 
       if(isEmpty()){ 
        cout<<"\nQueue Empty !!!\n"; 
        break; 
       } 
       TRAVERSE(); 
       break; 

      default : 
       cout<<"Please choose 1/2/3 !!! \n"; 
     } 
     cout<<"\nDo you want to continue(y/n):"; 
     cin>>ch; 

    }while(ch=='y'||ch=='Y'); //end of do loop 

    return 0; 
} 

void ENQUE(int x){ 

    Q[tail] = x; 
    tail =(tail+1)%MAX ;  //OR tail = (tail==MAX) ? 0 : tail+1 ; */ 
} 

int DEQUEUE(){ 

    int temp =Q[head]; 
    head =(head+1)%MAX ;  //OR head = (head==MAX) ? 0 : head+1 ; */ 
    return temp; 
} 

void TRAVERSE(){ 
    int i;        //simple case: Q -> [ ][ ][h7][8][9][5t][ ][ ][ ][ ][ ] 
    for(i=head; i!=tail; i=(i+1)% MAX) //complex case: Q -> [16][t][ ][ ][ ][h5][11][12][13][14][15] 
     cout<<Q[i]<<" "; 
    cout<<endl; 
} 

bool isEmpty(){ 
    if(head == tail) 
     return true; 
    else 
     return false; 
} 

bool isFull(){ 
    if((tail == MAX-1 && head == 0) || (head == tail + 1) ) 
     return true; 
    else 
     return false; 
} 

ही का एक वीडियो ट्यूटोरियल यहाँ देखा जा सकता: Data structures: Array implementation of Queue