Queue परिचय

एक queue water fountain पर एक line जैसी है: पहला kid जो पहुंचा वह पहले पीता है, और newcomers पीछे जाते हैं।

In this page:

What is a Queue?
Enqueue Operation
Dequeue Operation
Queue Front and Rear
Queue Applications

Syntax

markup

from collections import deque
queue = deque()
queue.append(item)        # enqueue at rear
item = queue.popleft()    # dequeue from front

What is a Queue?

एक queue एक linear data structure है जहां elements बिल्कुल उसी order में process होते हैं जिसमें वे आते हैं, एक rule जिसे FIFO कहते हैं, First In First Out, एक stack के LIFO order के विपरीत। Real-world examples में एक printer queue या एक ticket counter पर एक line शामिल है, जहां सबसे पहले पहुंचने वाला सबसे पहले serve होता है।

उदाहरण: What is a Queue?

#include <iostream>
#include <queue>
using namespace std;
int main() {
	queue<string> q;
	q.push("Person A"); q.push("Person B"); q.push("Person C");
	cout << "Served first: " << q.front();
	return 0;
}

import java.util.*;
public class Main {
	public static void main(String[] args) {
		Queue<String> q = new LinkedList<>();
		q.add("Person A"); q.add("Person B"); q.add("Person C");
		System.out.println("Served first: " + q.peek());
	}
}

from collections import deque
q = deque()
q.append("Person A")
q.append("Person B")
q.append("Person C")
print("Served first:", q[0])

#include <stdio.h>
int main() {
	char *q[3] = {"Person A", "Person B", "Person C"};
	printf("Served first: %s", q[0]);
	return 0;
}

Enqueue Operation

Enqueue वह operation है जो एक नया element जोड़ता है, और यह हमेशा queue के rear (back) पर होता है, पहले से इंतज़ार कर रहे किसी भी elements के पीछे जुड़ते हुए। एक array-based implementation में, इसका आमतौर पर मतलब है एक rear pointer increment करना और नए element को उस index पर रखना।

उदाहरण: Enqueue Operation

#include <iostream>
using namespace std;
int main() {
	int q[5], rear = -1;
	q[++rear] = 10;
	q[++rear] = 20;
	q[++rear] = 30;
	for (int i = 0; i <= rear; i++) cout << q[i] << " ";
	return 0;
}

public class Main {
	public static void main(String[] args) {
		int[] q = new int[5];
		int rear = -1;
		q[++rear] = 10;
		q[++rear] = 20;
		q[++rear] = 30;
		for (int i = 0; i <= rear; i++) System.out.print(q[i] + " ");
	}
}

q = [None] * 5
rear = -1
for val in (10, 20, 30):
    rear += 1
    q[rear] = val
print(q[:rear + 1])

#include <stdio.h>
int main() {
	int q[5], rear = -1;
	q[++rear] = 10;
	q[++rear] = 20;
	q[++rear] = 30;
	for (int i = 0; i <= rear; i++) printf("%d ", q[i]);
	return 0;
}

Dequeue Operation

Dequeue वह operation है जो एक element हटाता है, और यह हमेशा queue के front पर होता है, जिस element ने भी सबसे लंबा इंतज़ार किया है उसे लेते हुए। एक array-based implementation में, इसका मतलब है front pointer पर element पढ़ना और फिर उस pointer को आगे increment करना।

उदाहरण: Dequeue Operation

#include <iostream>
using namespace std;
int main() {
	int q[5] = {10, 20, 30};
	int front = 0, rear = 2;
	cout << "Removed: " << q[front] << endl;
	front++;
	cout << "New front: " << q[front];
	return 0;
}

public class Main {
	public static void main(String[] args) {
		int[] q = {10, 20, 30};
		int front = 0;
		System.out.println("Removed: " + q[front]);
		front++;
		System.out.println("New front: " + q[front]);
	}
}

q = [10, 20, 30]
front = 0
print("Removed:", q[front])
front += 1
print("New front:", q[front])

#include <stdio.h>
int main() {
	int q[3] = {10, 20, 30};
	int front = 0;
	printf("Removed: %d\n", q[front]);
	front++;
	printf("New front: %d", q[front]);
	return 0;
}

Queue Front and Rear

Front उस अगले element की ओर point करता है जो हटाया जाएगा, और rear उस जगह की ओर point करता है जहां अगला नया element जोड़ा जाएगा, और इन दो positions को सीधा रखना वह core bookkeeping है जो एक queue implementation को चाहिए।

उदाहरण: Queue Front and Rear

#include <iostream>
using namespace std;
int main() {
	int q[5], front = 0, rear = -1;
	q[++rear] = 5; q[++rear] = 15;
	cout << "Front index: " << front << ", Rear index: " << rear << endl;
	front++;
	cout << "After dequeue, front index: " << front;
	return 0;
}

public class Main {
	public static void main(String[] args) {
		int[] q = new int[5];
		int front = 0, rear = -1;
		q[++rear] = 5; q[++rear] = 15;
		System.out.println("Front index: " + front + ", Rear index: " + rear);
		front++;
		System.out.println("After dequeue, front index: " + front);
	}
}

q = [None] * 5
front, rear = 0, -1
for val in (5, 15):
    rear += 1
    q[rear] = val
print("Front index:", front, ", Rear index:", rear)
front += 1
print("After dequeue, front index:", front)

#include <stdio.h>
int main() {
	int q[5], front = 0, rear = -1;
	q[++rear] = 5; q[++rear] = 15;
	printf("Front index: %d, Rear index: %d\n", front, rear);
	front++;
	printf("After dequeue, front index: %d", front);
	return 0;
}

Queue Applications

Queues असली waiting lines को सीधे model करते हैं: task scheduling, data को stream में आते ही buffer करना, print job queues, और breadth-first search, जहां nodes उसी order में explore होते हैं जिसमें वे discover होते हैं।

उदाहरण: Queue Applications

#include <iostream>
#include <queue>
using namespace std;
int main() {
	queue<string> printJobs;
	printJobs.push("doc1.pdf"); printJobs.push("doc2.pdf"); printJobs.push("doc3.pdf");
	while (!printJobs.empty()) {
		cout << "Printing: " << printJobs.front() << endl;
		printJobs.pop();
	}
	return 0;
}

import java.util.*;
public class Main {
	public static void main(String[] args) {
		Queue<String> printJobs = new LinkedList<>();
		printJobs.add("doc1.pdf"); printJobs.add("doc2.pdf"); printJobs.add("doc3.pdf");
		while (!printJobs.isEmpty()) {
			System.out.println("Printing: " + printJobs.poll());
		}
	}
}

from collections import deque
print_jobs = deque(["doc1.pdf", "doc2.pdf", "doc3.pdf"])
while print_jobs:
    print("Printing:", print_jobs.popleft())

#include <stdio.h>
int main() {
	char *printJobs[3] = {"doc1.pdf", "doc2.pdf", "doc3.pdf"};
	for (int i = 0; i < 3; i++) printf("Printing: %s\n", printJobs[i]);
	return 0;
}

Chapter Quiz — Complete all 5 topics to unlock

0/5 topics done

Complete these topics first:

← Previous Lesson Monotonic Stack Next Lesson → Queue Implementation