Queue.pptx data strertyu vdtuin drtyujkf

flexonstudio39 8 views 32 slides Oct 28, 2025
Slide 1
Slide 1 of 32
Slide 1
1
Slide 2
2
Slide 3
3
Slide 4
4
Slide 5
5
Slide 6
6
Slide 7
7
Slide 8
8
Slide 9
9
Slide 10
10
Slide 11
11
Slide 12
12
Slide 13
13
Slide 14
14
Slide 15
15
Slide 16
16
Slide 17
17
Slide 18
18
Slide 19
19
Slide 20
20
Slide 21
21
Slide 22
22
Slide 23
23
Slide 24
24
Slide 25
25
Slide 26
26
Slide 27
27
Slide 28
28
Slide 29
29
Slide 30
30
Slide 31
31
Slide 32
32

About This Presentation

qwertyui asdfghj poiuy asdfg poiuy isc lkjhgf iyt nh


Slide Content

Queue Name : Muhammad Arslan Arid No: 23-arid-4348 Presented To : Ma’am Hina Umbrin

Introduction Types Operations Applications Advantages and Disadvantages Conclusion Outline

A Queue is a linear data structure in which elements are inserted from one end (called the rear ) and removed from the other end (called the front ) . It follows the FIFO (First In, First Out) principle, which means that the element that is added first will be removed first. The Queue structure is similar to a real-world queue, such as a queue in a line at a ticket counter, where the person who stands first in line is the first to be served. Introduction

Simple Queue Circular Queue Priority Queue Doubled-ended Queue Types

In a simple queue, elements are added at the rear and removed from the front, following the FIFO principle. Insertion (enqueue) and deletion (dequeue) operations are performed at opposite ends. Simple Queue

Simple Queue

Enqueue Algorithm Step 1: Check if the queue is full. If the rear pointer equals the maximum size (or if rear == size - 1), then the queue is full, and you cannot add more elements. Step 2: If there is space, insert the element at the rear of the queue. Step 3: Move the rear pointer one position forward. Step 4: If the rear pointer exceeds the size, no further insertion is allowed .

Dequeue Algorithm Step 1: Check if the queue is empty. If the front pointer equals the rear pointer (or front > rear), the queue is empty, and you cannot dequeue . Step 2: If the queue is not empty, remove the element from the front of the queue. Step 3: Move the front pointer one position forward . Step 4: If after dequeuing, the front pointer exceeds the rear pointer, the queue becomes empty.

A Circular Queue is the extended version of a regular queue where the last element is connected to the first element. Thus forming a circle-like structure I n a simple queue, once the queue is full, no new elements can be added until there is space available. Circular Queue

Circular Queue

Enqueue Algorithm Step 1: Check if the queue is full. In a circular queue, it is full if the next position of the rear pointer is equal to the front pointer (i.e., (rear + 1) % size == front). Step 2: If the queue is not full, insert the element at the rear. Step 3: Move the rear pointer forward, using the formula (rear + 1) % size to make sure it wraps around when it reaches the end of the array.

Dequeue Algorithm Step 1: Check if the queue is empty. If the front equals the rear, the queue is empty, and you cannot dequeue. Step 2: If there is an element to remove, remove the element at the front. Step 3: Move the front pointer forward, using the formula (front + 1) % size to ensure the circular behavior. Step 4: If the front and rear pointers meet after a dequeue operation, the queue becomes empty.

In a priority queue, each element is assigned a priority. Elements are dequeued in order of their priority rather than their arrival order. Higher priority element will get served first as compared to low priority element. Priority Queue

Priority Queue

Enqueue Algorithm Step 1: Assign a priority to the new element. Step 2: Compare the element’s priority with other elements in the queue . Step 3: Insert the new element at the correct position according to its priority (usually in sorted order, based on priority).

Dequeue Algorithm Step 1: Identify the element with the highest priority (or lowest priority, depending on the implementation). Step 2: Remove the element with the highest (or lowest) priority from the queue. Step 3: Adjust the remaining elements in the queue to maintain the priority order .

A deque allows insertion and deletion of elements at both ends (front and rear). There are two types of deques: Input-restricted deque: Deletion is allowed from both ends, but insertion is allowed only at one end. Output-restricted deque: Insertion is allowed at both ends, but deletion is allowed only at one end. Double-ended Queue

Double-ended Queue

Enqueue Algorithm Step 1: Check if there is space to insert the element. Step 2: Depending on the type of deque, either insert the element at the front or rear. For Input-restricted deques , insertion is allowed only at the rear. For Output-restricted deques, insertion is allowed at both ends . Step 3: Move the corresponding pointer(s) accordingly (either front or rear).

Dequeue Algorithm Step 1: Check if the queue is empty. If it is, there is nothing to dequeue. Step 2: Depending on the type of deque, either remove the element from the front or rear . For Input-restricted deques , removal is allowed only from the front . For Output-restricted deques, removal is allowed at both ends . Step 3: Adjust the corresponding pointer (either front or rear) accordingly.

Enqueue Algorithm : void enqueue(int queue[], int& rear, int value, int size) { if (rear == size - 1) { cout << "Queue is full!" << endl; return; } queue[rear + 1] = value; // Add value to the queue rear++; // Move rear pointer }

Dequeue Algorithm : int dequeue(int queue[], int& front, int rear) { if (front > rear) { cout << "Queue is empty!" << endl; return -1; // Indicating empty queue } int value = queue[front]; // Get value from the front front++; // Move front pointer return value; }

Enqueue (Insertion) The process of adding an element to the rear (or end) of the queue. Dequeue (Deletion) The process of removing an element from the front of the queue. Operations

Peek (Front) Returns the element at the front of the queue without removing it. isEmpty Checks if the queue is empty. Operations

IsFull Checks if the queue is full. Operations

In operating systems , a queue is used for scheduling tasks in the CPU, where processes are executed in the order they arrive. Printers often handle print jobs in a queue. The first job to be received is printed first, following the FIFO principle. Call centers use queues to manage incoming customer calls. The first call received is the first to be answered . Applications

In a bank queue , customers waiting in line are served based on the order of their arrival, with the first customer in the queue being the first to be served. A ticket booking system where users are in a queue to buy tickets. The first user to enter the system is the first to be served. Applications

FIFO Principle: Ensures that the first element added is the first one to be removed. Efficient for Scheduling: Great for real-time processing, such as CPU scheduling, task management, and handling requests. Simple Operations: The basic operations (enqueue and dequeue) are very straightforward and easy to implement. Advantages

Fixed Size: In a static queue (simple queue), the size is fixed, meaning that if the queue is full, no new elements can be added. Limited Access: In a queue, only the front element can be accessed (dequeued), and there’s no direct access to other elements like in an array or linked list. Disadvantages

Queues are a fundamental data structure in computer science that allows efficient management of elements in a FIFO manner. They are widely used in many real-world applications, such as task scheduling, request handling, process management, and network packet management. Conclusion

Thanks