डेटा स्ट्रक्चर डेटा का संग्रह है जो संरचित तरीके से व्यवस्थित होता है। इसे दो प्रकारों में विभाजित किया गया है:
लीनियर डेटा स्ट्रक्चर - डेटा एक रैखिक फैशन में व्यवस्थित होता है। उदाहरण: एरे, स्ट्रक्चर, स्टैक, क्यू, लिंक्ड लिस्ट।
नॉन-लीनियर डेटा स्ट्रक्चर - डेटा पदानुक्रमित तरीके से व्यवस्थित होता है। उदाहरण: ट्री, ग्राफ, सेट, टेबल।
क्यू
यह एक लीनियर डेटा स्ट्रक्चर है, जहां इन्सर्शन रियर एंड पर किया जाता है और डिलीशन फ्रंट एंड पर किया जाता है।
क्यू का क्रम FIFO है - फर्स्ट इन फर्स्ट आउट।
ऑपरेशन्स
- इन्सर्ट - क्यू में एलिमेंट इन्सर्ट करना।
- डिलीट - क्यू से एलिमेंट डिलीट करना।
शर्तें
क्यू ओवरफ्लो - भरे हुए क्यू में एलिमेंट इन्सर्ट करने का प्रयास।
क्यू अंडरफ्लो - खाली क्यू से एलिमेंट डिलीट करने का प्रयास।
एल्गोरिदम
इन्सर्शन ( ) के लिए एल्गोरिदम नीचे दिया गया है:
- क्यू ओवरफ्लो की जांच करें।
if (r == n) printf("Queue overflow")
- अन्यथा, क्यू में एलिमेंट इन्सर्ट करें।
q[r] = item r++
डिलीशन ( ) के लिए एल्गोरिदम नीचे दिया गया है:
- क्यू अंडरफ्लो की जांच करें।
if (f == r) printf("Queue under flow")
- अन्यथा, क्यू से एलिमेंट डिलीट करें।
item = q[f] f++
डिस्प्ले ( ) के लिए एल्गोरिदम नीचे दिया गया है:
- जांचें कि क्यू खाली है या नहीं।
if (f == r) printf("Queue is empty")
- अन्यथा, 'f' से 'r' तक सभी एलिमेंट्स प्रिंट करें।
for(i=f; i<r; i++) printf("%d", q[i]);
प्रोग्राम
एरे का उपयोग करके क्यू के कार्यान्वयन के लिए C प्रोग्राम निम्नलिखित है:
#include<limits.h>
#include<stdio.h>
#include <stdlib.h>
struct Queue {
int front, rear, size;
unsigned capacity;
int* array;
};
struct Queue* createQueue(unsigned capacity){
struct Queue* queue = (struct Queue*)malloc(sizeof(struct Queue));
queue->capacity = capacity;
queue->front = queue->size = 0;
queue->rear = capacity - 1;
queue->array = (int*)malloc(queue->capacity * sizeof(int));
return queue;
}
// क्यू भरा है या नहीं
int isFull(struct Queue* queue){
return (queue->size == queue->capacity);
}
// क्यू खाली है या नहीं
int isEmpty(struct Queue* queue){
return (queue->size == 0);
}
void Enqueue(struct Queue* queue, int item){
if (isFull(queue))
return;
queue->rear = (queue->rear + 1) % queue->capacity;
queue->array[queue->rear] = item;
queue->size = queue->size + 1;
printf("%d entered into queue\n", item);
}
int Dequeue(struct Queue* queue){
if (isEmpty(queue))
return INT_MIN;
int item = queue->array[queue->front];
queue->front = (queue->front + 1) % queue->capacity;
queue->size = queue->size - 1;
return item;
}
// क्यू के फ्रंट को प्राप्त करने का फंक्शन
int front(struct Queue* queue){
if (isEmpty(queue))
return INT_MIN;
return queue->array[queue->front];
}
// क्यू के रियर को प्राप्त करने का फंक्शन
int rear(struct Queue* queue){
if (isEmpty(queue))
return INT_MIN;
return queue->array[queue->rear];
}
int main(){
struct Queue* queue = createQueue(1000);
Enqueue(queue, 100);
Enqueue(queue, 200);
Enqueue(queue, 300);
Enqueue(queue, 400);
printf("%d is deleted element from queue\n\n", Dequeue(queue));
printf("1st item in queue is %d\n", front(queue));
printf("last item in queue %d\n", rear(queue));
return 0;
}
आउटपुट
जब उपरोक्त प्रोग्राम चलाया जाता है, तो यह निम्नलिखित परिणाम देता है:
100 entered into queue 200 entered into queue 300 entered into queue 400 entered into queue 100 is deleted element from queue 1st item in queue is 200 last item in queue 400
