← Back to DSA Course | Chapter 6: Queues | Lesson 3 of 5

Circular Queue क्या है

एक circular queue seats का एक merry-go-round जैसा है: जब आप आखिरी seat तक पहुंचते हैं आप वापस पहली खाली वाली में loop करते हैं, इसलिए कोई space waste नहीं होती।

In this page:

  1. Circular Queue Idea
  2. Enqueue in Circular Queue
  3. Dequeue in Circular Queue
  4. Full and Empty Conditions
  5. Circular Queue Practice
Syntax
markup 
rear = (rear + 1) % capacity     # enqueue: advance rear
front = (front + 1) % capacity   # dequeue: advance front

Circular Queue Idea

एक circular queue underlying array को एक loop की तरह treat करता है, आखिरी position को पहले से connect करने के लिए वापस wrapping करते हुए, जो इसे पहले dequeues से free हुई space को reuse करने देता है बजाय इसे एक plain array queue की तरह waste करने के।

उदाहरण: Circular Queue Idea

#include <iostream>
using namespace std;
int main() {
	int capacity = 4;
	int q[4] = {10, 20, 0, 0};
	int front = 0, rear = 1;
	front = (front + 1) % capacity;
	rear = (rear + 1) % capacity;
	q[rear] = 30;
	cout << "front=" << front << " rear=" << rear << " value=" << q[rear];
	return 0;
}
public class Main {
	public static void main(String[] args) {
		int capacity = 4;
		int[] q = {10, 20, 0, 0};
		int front = 0, rear = 1;
		front = (front + 1) % capacity;
		rear = (rear + 1) % capacity;
		q[rear] = 30;
		System.out.println("front=" + front + " rear=" + rear + " value=" + q[rear]);
	}
}
capacity = 4
q = [10, 20, 0, 0]
front, rear = 0, 1
front = (front + 1) % capacity
rear = (rear + 1) % capacity
q[rear] = 30
print("front=", front, "rear=", rear, "value=", q[rear])
#include <stdio.h>
int main() {
	int capacity = 4;
	int q[4] = {10, 20, 0, 0};
	int front = 0, rear = 1;
	front = (front + 1) % capacity;
	rear = (rear + 1) % capacity;
	q[rear] = 30;
	printf("front=%d rear=%d value=%d", front, rear, q[rear]);
	return 0;
}

Enqueue in Circular Queue

एक circular queue में Enqueue modulo operator (rear = (rear + 1) % capacity) उपयोग करके rear index advance करता है, इसलिए एक बार rear आखिरी array slot पार करे, यह naturally वापस index 0 पर wrap हो जाता है बजाय जगह खत्म होने के।

उदाहरण: Enqueue in Circular Queue

#include <iostream>
using namespace std;
int main() {
	int capacity = 5;
	int q[5], rear = -1, size = 0;
	for (int i = 1; i <= 3; i++) {
		rear = (rear + 1) % capacity;
		q[rear] = i * 10;
		size++;
	}
	cout << "rear index=" << rear << " last value=" << q[rear];
	return 0;
}
public class Main {
	public static void main(String[] args) {
		int capacity = 5;
		int[] q = new int[5];
		int rear = -1;
		for (int i = 1; i <= 3; i++) {
			rear = (rear + 1) % capacity;
			q[rear] = i * 10;
		}
		System.out.println("rear index=" + rear + " last value=" + q[rear]);
	}
}
capacity = 5
q = [0] * 5
rear = -1
for i in range(1, 4):
    rear = (rear + 1) % capacity
    q[rear] = i * 10
print("rear index=", rear, "last value=", q[rear])
#include <stdio.h>
int main() {
	int capacity = 5;
	int q[5], rear = -1;
	for (int i = 1; i <= 3; i++) {
		rear = (rear + 1) % capacity;
		q[rear] = i * 10;
	}
	printf("rear index=%d last value=%d", rear, q[rear]);
	return 0;
}

Dequeue in Circular Queue

Dequeue front index पर उसी तरह काम करता है, इसे modulo से आगे move करते हुए ताकि यह भी array boundary के आस-पास wrap हो, queue का logical order बरकरार रखते हुए जबकि यह physically उसी memory में loop करता है।

उदाहरण: Dequeue in Circular Queue

#include <iostream>
using namespace std;
int main() {
	int capacity = 5;
	int q[5] = {10, 20, 30};
	int front = 0;
	int removed = q[front];
	front = (front + 1) % capacity;
	cout << "removed=" << removed << " new front index=" << front;
	return 0;
}
public class Main {
	public static void main(String[] args) {
		int capacity = 5;
		int[] q = {10, 20, 30};
		int front = 0;
		int removed = q[front];
		front = (front + 1) % capacity;
		System.out.println("removed=" + removed + " new front index=" + front);
	}
}
capacity = 5
q = [10, 20, 30]
front = 0
removed = q[front]
front = (front + 1) % capacity
print("removed=", removed, "new front index=", front)
#include <stdio.h>
int main() {
	int capacity = 5;
	int q[3] = {10, 20, 30};
	int front = 0;
	int removed = q[front];
	front = (front + 1) % capacity;
	printf("removed=%d new front index=%d", removed, front);
	return 0;
}

Full and Empty Conditions

चूंकि front और rear एक खाली queue और एक पूरी तरह full queue दोनों के लिए उसी index पर end हो सकते हैं, एक circular queue implementation को इन दो states में बताने का एक explicit तरीका चाहिए, आमतौर पर एक अलग size counter या एक जानबूझकर unused slot।

उदाहरण: Full and Empty Conditions

#include <iostream>
using namespace std;
int main() {
	int capacity = 3, size = 0;
	size++; size++; size++;
	bool isFull = (size == capacity);
	bool isEmpty = (size == 0);
	cout << "isFull=" << isFull << " isEmpty=" << isEmpty;
	return 0;
}
public class Main {
	public static void main(String[] args) {
		int capacity = 3, size = 0;
		size++; size++; size++;
		boolean isFull = (size == capacity);
		boolean isEmpty = (size == 0);
		System.out.println("isFull=" + isFull + " isEmpty=" + isEmpty);
	}
}
capacity = 3
size = 0
size += 3
is_full = (size == capacity)
is_empty = (size == 0)
print("isFull=", is_full, "isEmpty=", is_empty)
#include <stdio.h>
int main() {
	int capacity = 3, size = 3;
	int isFull = (size == capacity);
	int isEmpty = (size == 0);
	printf("isFull=%d isEmpty=%d", isFull, isEmpty);
	return 0;
}

Circular Queue Practice

Circular queues standard choice हैं जब भी आपको एक fixed-capacity buffer चाहिए जो लगातार भरा और खाली किया जाता है, जैसे एक producer-consumer buffer या एक streaming data pipeline, क्योंकि वे कभी elements shift करने की ज़रूरत से बचते हैं।

उदाहरण: Circular Queue Practice

#include <iostream>
using namespace std;
int main() {
	int capacity = 3, q[3], front = 0, rear = -1, size = 0;
	for (int i = 1; i <= 3; i++) { rear = (rear + 1) % capacity; q[rear] = i; size++; }
	cout << "Removed: " << q[front] << endl;
	front = (front + 1) % capacity; size--;
	rear = (rear + 1) % capacity; q[rear] = 4; size++;
	cout << "Buffer wrapped, new value: " << q[rear];
	return 0;
}
public class Main {
	public static void main(String[] args) {
		int capacity = 3;
		int[] q = new int[3];
		int front = 0, rear = -1, size = 0;
		for (int i = 1; i <= 3; i++) { rear = (rear + 1) % capacity; q[rear] = i; size++; }
		System.out.println("Removed: " + q[front]);
		front = (front + 1) % capacity; size--;
		rear = (rear + 1) % capacity; q[rear] = 4; size++;
		System.out.println("Buffer wrapped, new value: " + q[rear]);
	}
}
capacity = 3
q = [0] * 3
front, rear, size = 0, -1, 0
for i in range(1, 4):
    rear = (rear + 1) % capacity
    q[rear] = i
    size += 1
print("Removed:", q[front])
front = (front + 1) % capacity
rear = (rear + 1) % capacity
q[rear] = 4
print("Buffer wrapped, new value:", q[rear])
#include <stdio.h>
int main() {
	int capacity = 3, q[3], front = 0, rear = -1;
	for (int i = 1; i <= 3; i++) { rear = (rear + 1) % capacity; q[rear] = i; }
	printf("Removed: %d\n", q[front]);
	front = (front + 1) % capacity;
	rear = (rear + 1) % capacity; q[rear] = 4;
	printf("Buffer wrapped, new value: %d", q[rear]);
	return 0;
}
Related Topics

Circular Linked List क्या है · Queue का Implementation · Deque यानि Double-ended Queue · Queue परिचय

{# common_mistakes/chapter_summary/browser_support: on Hindi pages the view already swaps in the hi_ translation fields (or blanks these out if untranslated), so this renders correctly for both languages without a lang_code check here. #}
आम गलतियां
  1. % capacity के बिना rear + 1 उपयोग करना, इसलिए index wrap होने के बजाय आखिर से आगे निकल जाता है।
  2. front == rear होने पर full को empty से अलग न करना, जब तक आप size track न करें या एक slot unused न छोड़ें।
  3. size घटाए बिना dequeue पर front advance करना, इसलिए queue कभी खाली नहीं दिखता।
🔒

Chapter Quiz — Complete all 5 topics to unlock

0/5 topics done

Complete these topics first:

← Previous Lesson Queue Implementation Next Lesson → Deque Double-ended Queue

Login to run this code

C/C++/Java/PHP execution requires a free account. Your code is saved — you'll land right back in the editor after logging in.