Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email
Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

# Data Structures Using C | Queue | Heap

Last Updated on October 10, 2022 by Gokul Kannan

A data structure is not only used for organizing the data. It is also used for processing, retrieving, and storing data. There are different basic and advanced types of data structures that are used in almost every program or software system that has been developed. So we must have good knowledge about data structures.

Data Structures using C is an important part of Programming. Get a better understanding of problems by watching these video tutorials created by expert mentors at PrepBytes.

### Why Learn Data Structure?

Data structure and algorithms are two of the most important aspects of computer science. Data structures allow us to organize and store data, while algorithms allow us to process that data in a meaningful way. Learning data structure and algorithms will help you become a better programmer. You will be able to write code that is more efficient and more reliable. You will also be able to solve problems more quickly and more effectively.

### Queue:

A queue can be defined as an ordered list which enables insert operations to be performed at one end called REAR and delete operations to be performed at another end called FRONT. Queue is referred to as First In First Out list.
For example, people waiting in line for a rail ticket form a queue.

### Operations performed on queue

The fundamental operations that can be performed on queue are listed as follows –

• Enqueue: The Enqueue operation is used to insert the element at the rear end of the queue. It returns void.
• Dequeue: It performs the deletion from the front-end of the queue. It also returns the element which has been removed from the front-end. It returns an integer value.
• Peek: This is the third operation that returns the element, which is pointed by the front pointer in the queue but does not delete it.
• Queue overflow (isfull): It shows the overflow condition when the queue is completely full.
• Queue underflow (isempty): It shows the underflow condition when the Queue is empty, i.e., no elements are in the Queue.

### Working of Queue

Queue operations work as follows:

• two pointers FRONT and REAR
• FRONT track the first element of the queue
• REAR track the last element of the queue
• initially, set value of FRONT and REAR to -1

### Enqueue Operation

• check if the queue is full
• for the first element, set the value of FRONT to 0
• increase the REAR index by 1
• add the new element in the position pointed to by REAR

### Dequeue Operation

• check if the queue is empty
• return the value pointed by FRONT
• increase the FRONT index by 1
• for the last element, reset the values of FRONT and REAR to -1

### Applications of Queue

Due to the fact that queue performs actions on a first in first out basis which is quite fair for the ordering of actions. There are various applications of queues discussed below.

1. Queues are widely used as waiting lists for a single shared resource like printer, disk, CPU.
2. Queues are used in asynchronous transfer of data (where data is not being transferred at the same rate between two processes) for eg. pipes, file IO, sockets.
3. Queues are used as buffers in most of the applications like MP3 media player, CD player, etc.
4. Queues are used to maintain the playlist in media players in order to add and remove the songs from the play-list.
5. Queues are used in operating systems for handling interrupts.

### Implementation:

```#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX 6

int intArray[MAX];
int front = 0;
int rear = -1;
int itemCount = 0;

int peek(){
return intArray[front];
}
bool isEmpty(){
return itemCount == 0;
}
bool isFull(){
return itemCount == MAX;
}
int size(){
return itemCount;
}
void insert(int data){
if(!isFull()){
if(rear == MAX-1){
rear = -1;
}
intArray[++rear] = data;
itemCount++;
}
}
int removeData(){
int data = intArray[front++];
if(front == MAX){
front = 0;
}
itemCount--;
return data;
}
int main() {
/* insert 5 items */
insert(3);
insert(5);
insert(9);
insert(1);
insert(12);

// front : 0
// rear  : 4
// ------------------
// index : 0 1 2 3 4
// ------------------
// queue : 3 5 9 1 12
insert(15);

// front : 0
// rear  : 5
// ---------------------
// index : 0 1 2 3 4  5
// ---------------------
// queue : 3 5 9 1 12 15
if(isFull()){
printf("Queue is full!\n");
}

// remove one item
int num = removeData();
printf("Element removed: %d\n",num);
// front : 1
// rear  : 5
// -------------------
// index : 1 2 3 4  5
// -------------------
// queue : 5 9 1 12 15

// insert more items
insert(16);

// front : 1
// rear  : -1
// ----------------------
// index : 0  1 2 3 4  5
// ----------------------
// queue : 16 5 9 1 12 15

// As queue is full, elements will not be inserted.
insert(17);
insert(18);

// ----------------------
// index : 0  1 2 3 4  5
// ----------------------
// queue : 16 5 9 1 12 15
printf("Element at front: %d\n",peek());

printf("----------------------\n");
printf("index : 5 4 3 2  1  0\n");
printf("----------------------\n");
printf("Queue:  ");
while(!isEmpty()){
int n = removeData();
printf("%d ",n);
}
}
```

### Heap:

Heap represents a special tree based data structure used to represent priority queue or for heap sort. We’re going to discuss binary heap trees specifically.

### Operations of Heap Data Structure:

• Heapify: a process of creating a heap from an array.
• Insertion: process to insert an element in existing heap time complexity O(log N).
• Deletion: deleting the top element of the heap or the highest priority element, and then organizing the heap and returning the element with time complexity O(log N).
• Peek: to check or find the most prior element in the heap, (max or min element for max and min heap).

### Types of Heap Data Structure

Generally, Heaps can be of two types:

1. Max-Heap: In a Max-Heap the key present at the root node must be greatest among the keys present at all of its children. The same property must be recursively true for all sub-trees in that Binary Tree.

1. Min-Heap: In a Min-Heap the key present at the root node must be minimum among the keys present at all of its children. The same property must be recursively true for all sub-trees in that Binary Tree.

Now let’s see the creation of the heap by using an example.

The task is to build a max-heap from the above array.

Total nodes = 11
Last non-leaf node index = (11/2)-1 = 4
Therefore, the last non-leaf node = 6

To build max-heap, heapify only the nodes:

[10,30,50,40,60] in reverse order

### Implementation:

```#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

int intArray[10];
int size;

bool isEmpty(){
return size == 0;
}
int getMinimum(){
return intArray[0];
}
int getLeftChildIndex(int nodeIndex){
return 2*nodeIndex +1;
}
int getRightChildIndex(int nodeIndex){
return 2*nodeIndex +2;
}
int getParentIndex(int nodeIndex){
return (nodeIndex -1)/2;
}
bool isFull(){
return size == 10;
}
/**
* Heap up the new element,until heap property is broken.
* Steps:
* 1. Compare node's value with parent's value.
* 2. Swap them, If they are in wrong order.
* */
void heapUp(int nodeIndex){
int parentIndex, tmp;
if (nodeIndex != 0) {
parentIndex = getParentIndex(nodeIndex);
if (intArray[parentIndex] > intArray[nodeIndex]) {
tmp = intArray[parentIndex];
intArray[parentIndex] = intArray[nodeIndex];
intArray[nodeIndex] = tmp;
heapUp(parentIndex);
}
}
}
/**
* Heap down the root element being least in value,until heap property is broken.
* Steps:
* 1.If current node has no children, done.
* 2.If current node has one children and heap property is broken,
* 3.Swap the current node and child node and heap down.
* 4.If current node has one children and heap property is broken, find smaller one
* 5.Swap the current node and child node and heap down.
* */
void heapDown(int nodeIndex){
int leftChildIndex, rightChildIndex, minIndex, tmp;
leftChildIndex = getLeftChildIndex(nodeIndex);
rightChildIndex = getRightChildIndex(nodeIndex);
if (rightChildIndex >= size) {
if (leftChildIndex >= size)
return;
else
minIndex = leftChildIndex;
} else {
if (intArray[leftChildIndex] <= intArray[rightChildIndex])
minIndex = leftChildIndex;
else
minIndex = rightChildIndex;
}
if (intArray[nodeIndex] > intArray[minIndex]) {
tmp = intArray[minIndex];
intArray[minIndex] = intArray[nodeIndex];
intArray[nodeIndex] = tmp;
heapDown(minIndex);
}
}
void insert(int value) {
size++;
intArray[size - 1] = value;
heapUp(size - 1);
}
void removeMin() {
intArray[0] = intArray[size - 1];
size--;
if (size > 0)
heapDown(0);
}
main() {
/*                     5                //Level 0
*
*/
insert(5);
/*                     1                //Level 0
*                     |
*                 5---|                 //Level 1
*/
insert(1);
/*                     1                //Level 0
*                     |
*                 5---|---3             //Level 1
*/
insert(3);
/*                     1                //Level 0
*                     |
*                 5---|---3             //Level 1
*                 |
*              8--|                     //Level 2
*/
insert(8);
/*                     1                //Level 0
*                     |
*                 5---|---3             //Level 1
*                 |
*              8--|--9                  //Level 2
*/
insert(9);
/*                     1                 //Level 0
*                     |
*                 5---|---3              //Level 1
*                 |       |
*              8--|--9 6--|              //Level 2
*/
insert(6);
/*                     1                 //Level 0
*                     |
*                 5---|---2              //Level 1
*                 |       |
*              8--|--9 6--|--3           //Level 2
*/
insert(2);

printf("%d", getMinimum());

removeMin();
/*                     2                 //Level 0
*                     |
*                 5---|---3              //Level 1
*                 |       |
*              8--|--9 6--|              //Level 2
*/
printf("\n%d", getMinimum());
}
```

Test your data structure skills by taking this Data Structures using C Mock Test designed by experienced mentors at PrepBytes.