Queue in Data Structure in Hindi | Queue हिंदी में

अगर आप Queue in Data Structure in Hindi जानना चाहते है तोह आप सही जगह पर है | यहाँ हम आपको Queue क बारे में सब कुछ बिस्तर से बातएंगे| बने रहें हमारे साथ और पूरा पोस्ट पढ़े |

What is Queue in Data Structure in Hindi ?

Queue एक महत्वपूर्ण Data Structure है जो कंप्यूटर अनुप्रयोग में व्यापक रूप से उपयोग की जाती है।

queue in data structure in hindi

इस लेख में हम Queue कैसे कम करता है, Queue का कार्यान्वयन, कैसे Arrays या Linked Lists के साथ कम करता है ओ जनेंगे।  

विभिन्न प्रकार की Queue जैसे multiple queues, double ended queues, circular queues, और priority queues, stack vs Queue और Queues का वास्तविक जीवन कार्यान्वयन के बारे मै जनेंगे।

Suppose एस्केलेटर पर चलते लोग। जो लोग पहले एस्केलेटर पर चढ़े हैं, वे सबसे पहले इससे बाहर निकलेंगे। बस का इंतजार कर रहे लोग। लाइन में खड़ा होने वाला पहला व्यक्ति बस में चढ़ने वाला पहला व्यक्ति होगा। सिनेमा हॉल की टिकट खिड़की के बाहर खड़े लोग।

लाइन में पहले व्यक्ति को पहले टिकट मिलेगा और इस तरह वह इससे बाहर निकलने वाला पहला व्यक्ति होगा। सामान कन्वेयर बेल्ट पर रखा जाता है। जो थैला पहले रखा गया वह दूसरे छोर पर सबसे पहले बाहर आएगा। टोल ब्रिज पर खड़ी car।

पुल पर पहुंचने वाली पहली car जाने वाली पहली car होगी। इन सभी उदाहरणों में, हम देखते हैं कि पहले स्थान पर मौजूद तत्व को पहले परोसा जाता है।

Queue Data Structure के साथ भी ऐसा ही है। queue एक FIFO (फर्स्ट-इन, फर्स्ट-आउट) data Structure है जिसमें जो तत्व पहले डाला जाता है वह बाहर निकाला जाने वाला पहला तत्व होता है।

एक Queue में तत्वों को एक छोर पर जोड़ा जाता है जिसे REAR कहा जाता है और दूसरे छोर से हटा दिया जाता है जिसे FRONT कहा जाता है।

Queue को या तो Arrays या Linked list का उपयोग करके लागू किया जा सकता है। इस article में, हम देखेंगे arrays and Linked list का उपयोग करके queue को कैसे लागू किया जाता है।

Types of Queue in Hindi

एक Data Structure मै Queue को निम्नलिखित प्रकारों में वर्गीकृत किया जा सकता है:

1. Circular Queue in Data Structure in Hindi  

Linear queue में, हमने अब तक चर्चा की है कि सम्मिलन केवल एक छोर पर किया जा सकता है जिसे कहा जाता है REAR और विलोपन हमेशा दूसरे छोर से किए जाते हैं जिन्हें FRONT कहा जाता है।

Circular Queue एक नियमित queue का विस्तारित संस्करण है जहाँ अंतिम तत्व पहले तत्व से जुड़ा होता है। इस प्रकार एक वृत्त जैसी structure का निर्माण होता है।

types of queue in hindi

Circular Queue सामान्य कतार की प्रमुख सीमा को हल करती है। एक सामान्य queue में, कुछ डालने और हटाने के बाद, अनुपयोगी खाली जगह होगी।

यहां, अनुक्रमित 0 और 1 का उपयोग केवल कतार को रीसेट करने (सभी तत्वों को हटाने) के बाद किया जा सकता है। यह कतार के वास्तविक आकार को कम करता है।

Circular Queue निम्नानुसार काम करती है:

Circular Queue  main दो pointers होता है सामने और पीछे ।

Front Queue के पहले तत्व को ट्रैक करता है

REAR queue के अंतिम तत्वों को ट्रैक करता है

प्रारंभ में, FRONT और REAR का मान -1 . पर सेट करें

1. Enqueue Operation

जांचें कि क्या कतार भरी हुई है

पहले तत्व के लिए, FRONT का मान 0 . पर सेट करें

REAR इंडेक्स को 1 से गोलाकार रूप से बढ़ाएं (अर्थात यदि पिछला अंत तक पहुंचता है, तो अगला यह कतार की शुरुआत में होगा)

REAR द्वारा इंगित स्थिति में नया तत्व जोड़ें

2. Dequeue Operation

जांचें कि क्या कतार खाली है

FRONT . द्वारा इंगित मान वापस करें

फ़्रंट इंडेक्स को 1 . से गोलाकार रूप से बढ़ाएं

अंतिम तत्व के लिए, FRONT और REAR के मानों को -1 . पर रीसेट करें

2. Deque in Hindi

Dqueue (‘डेक’ या ‘डेक्यू’ के रूप में उच्चारित) एक सूची है जिसमें तत्वों को सम्मिलित किया जा सकता है या

किसी भी छोर से हटा दिया गया। इसे हेड-टेल लिंक्ड लिस्ट के रूप में भी जाना जाता है क्योंकि इसमें तत्वों को जोड़ा जा सकता है या तो सामने (सिर) या पीछे (पूंछ) के सिरे से हटा दिया जाता है।

हालाँकि, बीच से कोई तत्व जोड़ा और हटाया नहीं जा सकता है। कंप्यूटर की मेमोरी में, a deque को या तो Circular array या एक सर्कुलर डबल लिंक्ड लिस्ट का उपयोग करके कार्यान्वित किया जाता है।

एक डेक में, दो Pointers बनाए रखा जाता है, बाएँ और दाएँ, जो डेक के किसी भी छोर की ओर इशारा करते हैं। एक में तत्वडेक बाएँ सिरे से दाएँ सिरे तक फैला हुआ है और चूँकि यह वृत्ताकार है, Dequeue[N–1] का अनुसरण किया जाता है डेक्यू [0] द्वारा।    

3. Priority Queue in Data Structure in Hindi

Priority Queue, Normal Queue की तुलना में अधिक विशिष्ट data structure है . Normal Queue की तरह, Priority Queue में एक ही विधि होती है लेकिन एक बड़ा अंतर होता है।

इसमें आइटम को कुंजी मान द्वारा आदेश दिया जाता है ताकि कुंजी के निम्नतम मूल्य वाला आइटम सामने हो और कुंजी के उच्चतम मूल्य वाला आइटम पीछे या इसके विपरीत हो |

इसलिए हमें आइटम को उसके मुख्य मूल्य के आधार पर प्राथमिकता दी जाती है | मूल्य कम, प्राथमिकता अधिक | प्राथमिकता कतार के प्रमुख तरीके निम्नलिखित हैं।

insert / enqueue − कतार के पीछे एक आइटम जोड़ें।

remove / dequeue − कतार के सामने से एक वस्तु को हटा दें।  

4. Multiple Queue in Hindi

जब हम एक array का उपयोग करके एक queue को लागू करते हैं, तो array का आकार पहले से ज्ञात होना चाहिए। अगर queue को कम जगह आवंटित की जाती है, फिर बार-बार अतिप्रवाह की स्थिति का सामना करना पड़ेगा।

साथ सौदा करने के लिए इस समस्या के लिए, कोड को array के लिए अधिक स्थान पुनः आवंटित करने के लिए संशोधित करना होगा। यदि हम array के लिए बड़ी मात्रा में जगह आवंटित करते हैं, तो इसका परिणाम काफी हद तक बर्बाद होगा याद।

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

Queue को Array और Linked List क साथ कैसे लागू करें

जैसे की आप जानते होंगे की Queue को दो तरह से दर्शाया जा सकता है Arrays और Linked list . यहाँ हम दोनों ही प्रकार बिस्तर से देखेंगे |

Queue Data Structure को Array क साथ कैसे लागू करें

**Example Implementation of a linear queue-

include <stdio.h>
include <conio.h>
#define MAX 10 
int queue[MAX];
int front = -1, rear = -1;
void insert(void);
int delete_element(void);
int peek(void);
void display(void);
int main()
{
int option, val;
do
{
printf(“\n\n ***** MAIN MENU *****”);
printf(“\n 1. Insert an element”);
printf(“\n 2. Delete an element”);
printf(“\n 3. Peek”);
printf(“\n 4. Display the queue”);
printf(“\n 5. EXIT”);
printf(“\n Enter your option : “);
scanf(“%d”, &option);
switch(option)
 {
case 1:
 insert();
break;
case 2:
val = delete_element();
if (val != -1)
printf(“\n The number deleted is : %d”, val);
break;
case 3:
val = peek();
if (val != -1)
printf(“\n The first value in queue is : %d”, val);
break;
case 4:
display();
break;
 }
}while(option != 5);
getch();
return 0;
}
void insert()
{
int num;
printf(“\n Enter the number to be inserted in the queue : “);
scanf(“%d”, &num);
if(rear == MAX-1)
printf(“\n OVERFLOW”);
else if(front == -1 && rear == -1)
front = rear = 0;
else
rear++;
queue[rear] = num;
}
int delete_element()
{
int val;
256 Data Structures Using C
if(front == -1 || front>rear)
{
printf(“\n UNDERFLOW”);
return -1;
}
else
{
val = queue[front];
front++;
if(front > rear)
front = rear = -1;
return val;
}
}
int peek()
{
if(front==-1 || front>rear)
{
printf(“\n QUEUE IS EMPTY”);
return -1;
}
else
{
return queue[front];
}
}
void display()
{
int i;
printf(“\n”);
if(front == -1 || front > rear)
printf(“\n QUEUE IS EMPTY”);
else
{
for(i = front;i <= rear;i++)
printf(“\t %d”, queue[i]);
}
}

Output

***** MAIN MENU *****

  • Insert an element
  • Delete an element
  • Peek
  • Display the queue
  • EXIT

Enter your option : 1

Enter the number to be inserted in the queue : 50

Queue को Linked Lists क साथ कैसे लागू करें

#include <stdio.h>
#include <conio.h>
#include <malloc.h>
struct node
{
int data;
struct node *next;
};
struct queue
{
struct node *front;
struct node *rear;
};
struct queue *q;
void create_queue(struct queue *);
struct queue *insert(struct queue *,int);
struct queue *delete_element(struct queue *);
struct queue *display(struct queue *);
int peek(struct queue *);
int main()
{
int val, option;
create_queue(q);
clrscr();
do
{

 	printf("\n *****MAIN MENU*****");
printf("\n 1. INSERT");
 	printf("\n 2. DELETE");
printf("\n 3. PEEK");
 printf("\n 4. DISPLAY");
 printf("\n 5. EXIT");
 printf("\n Enter your option : ");
 scanf("%d", &option);
switch(option)
 {
 	case 1:
 printf("\n Enter the number to insert in the queue:");
 scanf("%d", &val);
 q = insert(q,val);
 break;
 	case 2:
 q = delete_element(q);
 break;
 case 3:
 val = peek(q);
 if(val! = –1)
 	printf("\n The value at front of queue is : %d", val);
 	break;
 case 4:
 q = display(q);
 break;
 }
}while(option != 5);
getch();
return 0;
}
void create_queue(struct queue *q)
{
q -> rear = NULL;
q -> front = NULL;
}
struct queue *insert(struct queue *q,int val)
{
struct node *ptr;
ptr = (struct node*)malloc(sizeof(struct node));
ptr -> data = val;
if(q -> front == NULL)
{
 q -> front = ptr;
 q -> rear = ptr;
 q -> front -> next = q -> rear -> next = NULL;
}
else
{
 q -> rear -> next = ptr;
 q -> rear = ptr;
 q -> rear -> next = NULL;
}
return q;
}
struct queue *display(struct queue *q)
{
struct node *ptr;
ptr = q -> front;
if(ptr == NULL)
 printf("\n QUEUE IS EMPTY");
else
{
 printf("\n");
while(ptr!=q -> rear)
 {
 printf("%d\t", ptr -> data);
 ptr = ptr -> next;
 }
 printf("%d\t", ptr -> data);
}
return q;
}
struct queue *delete_element(struct queue *q)
{
struct node *ptr;
ptr = q -> front;
if(q -> front == NULL)
 printf("\n UNDERFLOW");
else
{
 q -> front = q -> front -> next;
 printf("\n The value being deleted is : %d", ptr -> data);
 free(ptr);
}
return q;
}
int peek(struct queue *q)
{
if(q->front==NULL)
{
 printf("\n QUEUE IS EMPTY");
 return –1;
}
else
 return q->front->data;
}

Output

*****MAIN MENU*****

  1. INSERT
  2. DELETE
  3. PEEK
  4. DISPLAY
  5. EXIT

Enter your option : 3

QUEUE IS EMPTY

Enter your option : 5

अगर आप बिस्तर में केओए क बारे में सीखना चाहते है तोह आप यहाँ से सिख सकते है – Queue

Stack और Queue के बीच अंतर

स्टैक एक रैखिक data structure है जिसमें तत्वों को सूची के केवल एक तरफ से डाला और हटाया जा सकता है, जिसे शीर्ष कहा जाता है।

एक स्टैक LIFO (लास्ट इन फर्स्ट आउट) सिद्धांत का अनुसरण करता है, अर्थात, सबसे अंत में डाला गया तत्व बाहर आने वाला पहला तत्व है।

स्टैक में किसी तत्व को सम्मिलित करने को पुश ऑपरेशन कहा जाता है, और स्टैक से किसी तत्व को हटाने को पॉप ऑपरेशन कहा जाता है। स्टैक में हम हमेशा सूची में मौजूद अंतिम तत्व का ट्रैक रखते हैं, जिसे शीर्ष कहा जाता है।

Queue एक रेखीय data structure है जिसमें तत्वों को सूची के केवल एक तरफ से डाला जा सकता है जिसे पीछे कहा जाता है, और तत्वों को केवल दूसरी तरफ से हटाया जा सकता है जिसे सामने कहा जाता है।

Queue data structure FIFO (फर्स्ट इन फर्स्ट आउट) सिद्धांत का अनुसरण करती है, अर्थात सूची में सबसे पहले डाला गया तत्व, सूची से हटाया जाने वाला पहला तत्व है। कतार में किसी तत्व के सम्मिलन को एनक्यू ऑपरेशन कहा जाता है और किसी तत्व को हटाने को डीक्यू ऑपरेशन कहा जाता है।

Data Structure में Queue में हम हमेशा दो pointers बनाए रखते हैं, एक उस तत्व की ओर इशारा करता है जिसे पहले डाला गया था और अभी भी सामने वाले pointers के साथ सूची में मौजूद है और दूसरा पॉइंटर पिछले पॉइंटर के साथ आखिरी में डाले गए तत्व की ओर इशारा करता है।

Application of Queue in Data Structure in Hindi

Printer, disk, CPU जैसे एकल साझा संसाधन के लिए Queue का व्यापक रूप से प्रतीक्षा सूची के रूप में उपयोग किया जाता है।

डेटा को asynchronously रूप से स्थानांतरित करने के लिए Queue का उपयोग किया जाता है (डेटा आवश्यक रूप से समान दर पर प्राप्त नहीं होता है जैसा भेजा गया) दो प्रक्रियाओं (आईओ बफर) के बीच, उदाहरण के लिए, पाइप, फ़ाइल आईओ, सॉकेट।

MP3 players और portable CD players, iPod playlist पर बफर के रूप में कतारों का उपयोग किया जाता है।

interrupts को संभालने के लिए ऑपरेटिंग सिस्टम में queue का उपयोग किया जाता है। रीयल-टाइम प्रोग्रामिंग करते समय सिस्टम जिसे बाधित किया जा सकता है, उदाहरण के लिए, माउस क्लिक द्वारा, इसे संसाधित करना आवश्यक है ।

वर्तमान कार्य के साथ आगे बढ़ने से पहले तुरंत बाधित हो जाता है। अगर व्यवधान होना ही है। आगमन के क्रम में संभाला जाता है, तो एक फीफो कतार उपयुक्त डेटा संरचना है।

निष्कर्ष : Queue in Data Structure in Hindi

आसा करता हु की आपको ये टॉपिक queue in data structure in hindi अच्छे से समझ में आया होगा |

अगर आप C program के structure के बारे में जानना चाहते है तोह ये पोस्ट जरूर पढ़े : Structure of C program in hindi |

यैसे ही और पोस्ट पढ़ने क लिए हमारे होमपेज पर जाये |

Leave a Comment