Open-Source Internship opportunity by OpenGenus for programmers. Apply now.
In this article, we have explained 2 approaches to implement K queues in a single array. The challenge is that the space of the array should be utilized optimally by the K queues.
Table of content
Method A
A1. A simple approach
A2. Algorithm
A3. Time & Space complexity
A4. A way of implementation
Method B
B1. An efficient approach
B2. Algorithm
B3. Time & Space complexity
B4. A way of implementation
Pre-requisites:
Method A
A1. A simple approach
As we could see in this article implementing 2 queues in an array required implementing 2 push and pop methods for each queue in the array.
How about doing this hard coding for k queues ? Doesn't sound too good, right ?
A logical approach to solve this is to use another parameter k representing the queue that needs to be modified and sending it to the push and pop methods.
But that will not be sufficient since we do not know exactly the heads of the k queues. So, we must calculate them. Since we cannot have a hard coded variables the only way is to use an array that will store the indexes for the queues.
The simplest way to do that is to see if there are remained elements that don't belong to any queue, and that because an array might have even or odd numbers of elements. The number of them can be simple to find by using the mod function and then increase the index of the first rest number of queues by 1.
For example:
- having an array of 6 elements and 3 queues will mean that each queue will have 2 elements with the head indexes for the queues [2,4,6]
- having an array of 5 elements and 3 queues will mean that not all the queues will be equals. We will have in this case 2 elements unallocated, so the last queue will have with 1 element less than the first ones having the head indexes for the queues [2,4,5]
The downsize of this approach is that it is space inefficient, meaning the size of the queues are fixed and if we want to insert one element in a full queue we cannot do that even though there are free spaces in other queues.
A2. Algorithm
The algorithm for push and pop methods will be the same as in the mentioned article the only difference consisted in calculating the indexes for each queue.
For that we are going to use 2 arrays:
- one for storing the heads of each queue
- one for storing the movement of elements inside each queue
Pseudo code for calculating the indexes of the k queues
if k > 0 and sizeArray >= k
sizeQueue = sizeArray / k;
sizeRest = sizeArray mod k;
array idxQk[k] that will store the moved index of the k queue
array idxQh[k] that will store the head index of the k queue
i = 0;
loop
if i < sizeRest
idxQk[i] <- sizeQueue +1;
idxQh[i] <- idxQk[i];
i <- i+1
end loop
i = sizeRest;
loop
if i < k
idxQk[i] <- sizeQueue ;
idxQh[i] <- idxQk[i];
i <- i+1;
end loop
A3. Time & Space complexity
For calculating indexes for k queues the time and space will be O(n).
For push method the time will be O(1) since we are doing one operation.
For pop method the time will be O(n) since we are moving elements.
A4. A way of implementation
#include <iostream>
using namespace std;
class kQueuesArray
{
private:
int *v, sizeV, sizeQ, sizeR, *idxQk, *idxQh;
public:
kQueuesArray(int size, int k)
{int i;
if (size > 0)
{
v = new int[size];
sizeV = size;
if (k > 0 && size >= k)
sizeQ = sizeV / k;
sizeR = sizeV % k;
idxQk = new int [k]; //store the moved index of the k queue
idxQh = new int [k]; //store the head index of the k queue
for (i = 0; i < sizeR; i++)
{
idxQk[i] = (i-1 >= 0 ? idxQk[i-1] : 0 ) + sizeQ +1;
idxQh[i] = idxQk[i];
}
for (i = sizeR ; i < k; i++)
{
idxQk[i] = (i-1 >= 0 ? idxQk[i-1] : 0 ) + sizeQ ;
idxQh[i] = idxQk[i];
}
/*
some languages start indexing arrays with 0 so
we need to adjust calculated indexes by decreasing them with 1
*/
for (i = 0; i < k; i++)
{
idxQk[i]--;
idxQh[i] = idxQk[i];
}
}
}
void pushQk(int elem, int Qk)
{
if (v[idxQk[Qk-1]]==0 && idxQk[Qk-1] >= 0 )
v[idxQk[Qk-1]--] = elem;
//else Queue k is full
}
int popQk(int Qk)
{
int temp;
if ( v[idxQh[Qk-1]] )
{
temp = v[idxQh[Qk-1]] ;
if(idxQk[Qk-1] < idxQh[Qk-1]-1 )
for (int i=idxQh[Qk-1]; i-1 > idxQk[Qk-1] ;i--) //move all the elements to the right
{
v[i] = v[i-1];
v[i-1] = 0;
}
else
v[idxQh[Qk-1]] = 0;
idxQk[Qk-1]++;
}
//else Queue k is empty
return temp;
}
void coutV()
{
for (int i=0;i<sizeV;i++)
cout<<"v["<<i<<"]="<<v[i]<<" ";
cout<<endl;
}
};
int main()
{
kQueuesArray a(5,3);
a.pushQk(11,1);
a.pushQk(12,1);
a.pushQk(13,1);
a.pushQk(21,2);
a.pushQk(22,2);
a.pushQk(31,3);
a.coutV();
cout<<a.popQk(2)<<endl;
a.coutV();
a.pushQk(23,2);
a.coutV();
cout<<a.popQk(3)<<endl;
a.coutV();
a.pushQk(32,3);
a.coutV();
return 0;
}
Step by step example
Method B
B1. An efficient approach
As we could see from the previous method, again, size of the k queues are fixed in size.
Can we find a way to store elements in an array in such a way to store them dynamically?
As we could see in the 2-nd method from the mentioned article, an array has only 2 heads and we could implemented the efficient storing of elements only for 2 queues.
So, that approach will not work for k queues.
What if we will use the pointer arithmetic logic and store for each element in the array the next element from the k queue that points to it ?
As you could see in the image, the elements that belong to same queue are not store side by side as in previous methods.
The main logic of this approach is to store for each queue, the front, the rear and the next elements inside of it.
B2. Algorithm
Initialization
- front and rear arrays are initialized with -1 indicating the empty queues
- next array will be initialize with the next index in the array except for the last element which will be -1 indicating nothing to point to.
- empty_slot a variable which stores the index of next empty slot in the array, at first will be 0
push(elem, k)
if empty_slot != -1
array[empty_slot] <- elem
last_empty_slot = empty_slot
last_front = front[k]
front[k] <- empty_slot
if rear[k] == -1
rear[k] <- empty_slot
empty_slot <- next[empty_slot];
next[last_empty_slot] = -1;
if (front[k] != fear[k])
next[last_front] = last_empty_slot;
else
queue k is full
Since push is a forward implementation:
- front will store the current empty slot
- rear will store also the current empty slot if it was empty and nothing else if the queue already has a rear head
- next will store -1 if the element is the last head in the queue or it doesn't belong to any queue, else the index of the next element
- empty_slot will store the next available slot in the array
pop(k)
if rear[k] != -1
array[rear[k]] <- nil
last_rear = rear[k]
if next[rear[k]] == -1
front[k] <- -1
rear[k] <- next[rear[k]]
empty_slot <- last_rear
idxNext[last_rear] <- -1
else
queue k is empty
Since pop is a backward implementation:
- front will store -1 if the next rear head is empty else nothing to change
- rear will store the next rear head
- next will store -1 in the last rear element since it doesn't point to anything
- empty_slot will store the last rear head
B3. Time & Space complexity
For push method the time will be O(1) since we are doing one operation.
For pop method the time will be O(1) since we are doing one operation.
The space comlexity is O(n).
B4. A way of implementation
#include <iostream>
using namespace std;
class kQueuesArray
{
private:
int *v, sizeV, sizeQ, *idxQFront, *idxQRear, *idxNext, empty_slot;
public:
kQueuesArray(int size, int k)
{
int i;
if (size > 0)
{
v = new int[size];
sizeV = size;
if (k > 0 && size >= k)
sizeQ = k;
idxQFront = new int [k]; //store the front index of the k queue
idxQRear = new int [k]; //store the rear index of the k queue
idxNext = new int[size];
for (i = 0; i < k; i++)
{
idxQFront[i] = idxQRear[i] = -1;
}
for (i = 0 ; i < size-1; i++)
{
idxNext[i] = i+1;
}
idxNext[sizeV-1] = -1; //mark the end of array
empty_slot = 0; //mark the next empty slot in the array
}
}
void pushQk(int elem, int Qk)
{
int last_front, last_empty_slot;
if(empty_slot != -1)
{
v[empty_slot] = elem,
last_empty_slot = empty_slot,
last_front = idxQFront[Qk-1],
idxQFront[Qk-1] = empty_slot,
idxQRear[Qk-1] = (idxQRear[Qk-1] == -1 ? empty_slot : idxQRear[Qk-1]),
empty_slot = idxNext[empty_slot];
idxNext[last_empty_slot] = -1;
if (idxQFront[Qk-1] != idxQRear[Qk-1])
idxNext[last_front] = last_empty_slot;
}
else cout<<"Queue is full"<<endl;
}
int popQk(int Qk)
{ int temp, last_rear;
if(idxQRear[Qk-1] != -1)
temp = v[idxQRear[Qk-1]],
v[idxQRear[Qk-1]] = 0,
last_rear = idxQRear[Qk-1],
idxQFront[Qk-1] = idxNext[idxQRear[Qk-1]] == -1 ? -1: idxQFront[Qk-1],
idxQRear[Qk-1] = idxNext[idxQRear[Qk-1]],
empty_slot = last_rear,
idxNext[last_rear] = -1;
else cout<<"Queue is empty"<<endl;
return temp;
}
void coutV()
{
for (int i=0;i<sizeV;i++)
cout<<"v["<<i<<"]="<<v[i]<<" ";
cout<<endl;
}
};
int main()
{
kQueuesArray a(5,3);
a.coutV();
a.pushQk(11,1);
a.pushQk(21,2);
a.pushQk(12,1);
a.pushQk(13,1);
a.pushQk(22,2);
a.pushQk(31,3);
a.coutV();
cout<<a.popQk(1)<<endl;
a.coutV();
a.pushQk(23,2);
a.coutV();
cout<<a.popQk(1)<<endl;
a.coutV();
a.pushQk(24,2);
a.coutV();
cout<<a.popQk(1)<<endl;
a.coutV();
a.pushQk(31,3);
a.coutV();
a.popQk(2);
a.coutV();
a.pushQk(32,3);
a.coutV();
return 0;
}
Step by step example
With this article at OpenGenus, you must have the complete idea of how to implement K queues in an array.
