📘 Lesson · Lesson 64

Queue using Linked List

Q: C में linked list से queue कैसे implement करते हैं?

आप दो pointers रखते हैं, front और rear। Enqueue के लिए एक नया node बनाकर rear के बाद जोड़ते हैं, फिर rear उस पर ले जाते हैं। Dequeue के लिए front वाला node लेते हैं, front अगले node पर ले जाते हैं, और पुराना free करते हैं। इससे queue run time पर बढ़ती-घटती है।

Q: Linked-list queue में front और rear किस ओर इशारा करते हैं?

front पहले node की ओर — अगले हटने वाले item — और rear आख़िरी node की ओर, जहाँ नए items जुड़ते हैं। Queue खाली होने पर दोनों NULL होते हैं।

Q: आख़िरी element dequeue करने पर क्या होता है?

इकलौता node हटाने के बाद front NULL हो जाता है। आपको rear को भी NULL करना होगा, वरना rear free हुई memory की ओर इशारा करेगा और अगला enqueue गड़बड़ करेगा। इस स्थिति को संभालना आम bug स्रोत है।

Linked-list queue क्यों?

Queue FIFO मानता है — First In, First Out। इसे array से बना सकते हैं (देखें C में queue), पर सामान्य array queue की दो कमज़ोरियाँ हैं: fixed size, और कई dequeue के बाद बर्बाद slots। Linked-list queue हर item के लिए node allocate करके और हटने पर free करके दोनों ठीक करता है।

अगर linked lists नई हैं तो पहले C में linked list पढ़ें — यह lesson सीधे nodes पर बनता है।

front और rear pointers

Node श्रृंखला में हम queue को दो pointers से track करते हैं:

Pointer	किस ओर
`front`	पहला node — अगला हटने वाला
`rear`	आख़िरी node — जहाँ जोड़ते हैं

खाली queue के लिए दोनों NULL से शुरू।

Rear पर enqueue

Node बनाएँ, rear के बाद जोड़ें, और rear आगे बढ़ाएँ।

C Language

void enqueue(int x) {
    struct Node *n = malloc(sizeof(struct Node));
    n->data = x; n->next = NULL;
    if (rear == NULL) { front = rear = n; return; }  // khaali
    rear->next = n;       // rear ke baad link
    rear = n;            // naya rear
}

Front पर dequeue

Front node लें, front आगे बढ़ाएँ, और पुराना node free करें।

C Language

int dequeue() {
    if (front == NULL) { printf("Queue empty\n"); return -1; }
    struct Node *temp = front;
    int x = temp->data;
    front = front->next;
    if (front == NULL) rear = NULL;   // yahi aakhri node tha!
    free(temp);
    return x;
}

⚠️ आख़िरी-node जाल

जब आप आख़िरी node dequeue करते हैं, front NULL हो जाता है। आपको rear को भी NULL करना होगा, वरना वह free हुई memory पर लटका रहेगा।

पूरा program

C Language

#include <stdio.h>
#include <stdlib.h>
struct Node { int data; struct Node *next; };
struct Node *front = NULL, *rear = NULL;

void enqueue(int x) {
    struct Node *n = malloc(sizeof(struct Node));
    n->data = x; n->next = NULL;
    if (rear == NULL) { front = rear = n; return; }
    rear->next = n; rear = n;
}
int dequeue() {
    if (front == NULL) { printf("Empty\n"); return -1; }
    struct Node *temp = front;
    int x = temp->data;
    front = front->next;
    if (front == NULL) rear = NULL;
    free(temp);
    return x;
}
int main() {
    enqueue(10); enqueue(20); enqueue(30);
    printf("Removed: %d\n", dequeue());  // 10
    printf("Removed: %d\n", dequeue());  // 20
    return 0;
}

Output:
Removed: 10
Removed: 20

Dry run

क्रिया	front	rear	Queue
enqueue 10	10	10	10
enqueue 20	10	20	10, 20
enqueue 30	10	30	10, 20, 30
dequeue → 10	20	30	20, 30

आम गलतियाँ

आख़िरी node dequeue होने पर rear = NULL set करना भूलना।
Enqueue में empty case न संभालना (दोनों pointers NULL से शुरू)।
Dequeue किए node को free करना भूलना, जिससे memory leak होता है।
Front पर जोड़ना या rear पर हटाना — यह FIFO क्रम तोड़ता है।

🏋️ अभ्यास

एक display() function जोड़ें जो front से अंत तक चलकर हर value print करे, और हर operation के बाद उसे call करके queue बदलते देखें।

सारांश

Linked-list queue front और rear node pointers इस्तेमाल करता है।
Enqueue rear पर node जोड़ता है; dequeue front से हटाता है।
यह run time पर बढ़ता-घटता है — न fixed size, न बर्बाद slots।
आख़िरी node जाने पर rear को NULL करें।
Leaks से बचने के लिए हटाए node को हमेशा free करें।

अक्सर पूछे जाने वाले प्रश्न (FAQ)

C में linked list से queue कैसे implement करते हैं?

आप दो pointers रखते हैं, front और rear। Enqueue के लिए एक नया node बनाकर rear के बाद जोड़ते हैं, फिर rear उस पर ले जाते हैं। Dequeue के लिए front वाला node लेते हैं, front अगले node पर ले जाते हैं, और पुराना free करते हैं। इससे queue run time पर बढ़ती-घटती है।

Queue के लिए array के बजाय linked list क्यों?

Linked-list queue का कोई fixed size नहीं, इसलिए memory खत्म होने तक overflow नहीं होता, और कई dequeue के बाद सामान्य array queue की तरह slots बर्बाद नहीं होते। हर node सिर्फ़ ज़रूरत पर allocate और हटने पर free होता है, तो space असल items के बराबर रहता है।

Linked-list queue में front और rear किस ओर इशारा करते हैं?

front पहले node की ओर — अगले हटने वाले item — और rear आख़िरी node की ओर, जहाँ नए items जुड़ते हैं। Queue खाली होने पर दोनों NULL होते हैं।

आख़िरी element dequeue करने पर क्या होता है?

इकलौता node हटाने के बाद front NULL हो जाता है। आपको rear को भी NULL करना होगा, वरना rear free हुई memory की ओर इशारा करेगा और अगला enqueue गड़बड़ करेगा। इस स्थिति को संभालना आम bug स्रोत है।

क्या linked-list queue FIFO है?

हाँ। Items rear पर जुड़ते और front से हटते हैं, तो पहला enqueue हुआ item पहले dequeue होता है — किसी भी queue का बिल्कुल First In, First Out व्यवहार, बस array के बजाय nodes से बना।

← Back to C Tutorial

💻 लाइव कोड एडिटर

इस पेज के प्रोग्राम यहीं तैयार हैं — चलाएँ, बदलें और सीखें। कुछ भी इंस्टॉल किए बिना।

OneCompiler द्वारा संचालित। कोड एडिटर में अपने आप आ जाता है — Run दबाकर आउटपुट देखें। अगर एडिटर न खुले तो नए टैब में खोलें.