Posted on by Kalkicode
Code Queue

Efficiently implement n queues in a single array

Efficiently implementing multiple queues in a single array. This can be particularly useful when you have limited memory space and want to maximize its utilization by sharing it among multiple queues.

Problem Statement

Given the constraint of using a single array, you need to implement a mechanism to handle multiple queues efficiently using the available memory.

Example Scenario

Imagine you have a limited amount of memory, and you need to manage data in several different queues. Instead of allocating separate memory blocks for each queue, you want to find a way to store the elements of all queues in a single array while ensuring proper queue operations.

Idea to Solve the Problem

The idea is to create an efficient data structure to represent multiple queues within a single array. This can be achieved by using the concept of a "circular linked list" for each queue. Each element in the array contains the data for an item and an index to the next element in the queue. The front and tail pointers of each queue point to the first and last elements of that queue, respectively. A next array maintains the link between elements in the array.

Pseudocode

struct NQueue *makeQueue(int element, int n)
{
    // Create dynamic NQueue
    
    // Create memory for queue elements, next, front, and tail
    
    // Initialize counter, element, and part values
    
    // Initialize front and tail values
    
    // Set next and data values
    
    // Return the created queue
}

int isEmpty(struct NQueue *q, int selection)
{
    // Check if the queue is empty
}

int isFull(struct NQueue *q)
{
    // Check if the queue is full
}

void enqueue(struct NQueue *q, int selection, int data)
{
    // Add a new element to the queue
}

int dequeue(struct NQueue *q, int selection)
{
    // Remove an element from the queue
}

void printQueue(struct NQueue *q)
{
    // Print the elements of all queues
}

Algorithm Explanation

  1. Implement the makeQueue function to create the NQueue structure and initialize necessary variables.
  2. Implement the isEmpty function to check if a specific queue is empty.
  3. Implement the isFull function to check if the entire structure is full.
  4. Implement the enqueue function to add an element to a specific queue.
  5. Implement the dequeue function to remove an element from a specific queue.
  6. Implement the printQueue function to print the elements of all queues.
  7. In the main function, create the NQueue using makeQueue.
  8. Enqueue and dequeue elements to demonstrate the functionality.

Code Solution

/*
    C Program 
    Efficiently implement n queues in a single array
*/
#include <stdio.h>

#include <stdlib.h>

// Structure of queue
struct NQueue
{
	int element;
	int part;
	int *data;
	int *front;
	int *tail;
	int *next;
	int counter;
};
struct NQueue *makeQueue(int element, int n)
{
	if (n <= 0 || element == 0)
	{
		return NULL;
	}
	// Create dynamic NQueue
	struct NQueue *q = (struct NQueue *) malloc(sizeof(struct NQueue));
	if (q == NULL)
	{
		printf("\n Memory Overflow, when creating a new Queue\n");
	}
	else
	{
		// Create memory of queue elements
		q->data = (int *) malloc(element *sizeof(int));
		q->next = (int *) malloc(element *sizeof(int));
		q->front = (int *) malloc(n *sizeof(int));
		q->tail = (int *) malloc(n *sizeof(int));
		q->counter = 0;
		q->element = element;
		q->part = n;
		int i = 0;
		// Set the initial value of front and tail of queue
		for (i = 0; i < n; ++i)
		{
			q->front[i] = -1;
			q->tail[i] = -1;
		}
		// Set next and data value
		for (i = 0; i < element - 1; ++i)
		{
			q->data[i] = 0;
			q->next[i] = i + 1;
		}
		q->next[element - 1] = -1;
		q->data[element - 1] = 0;
	}
	return q;
}
// Determine that given queue is empty or not
int isEmpty(struct NQueue *q, int selection)
{
	return q->front[selection] == -1;
}
// Determine that given queue is full or not
int isFull(struct NQueue *q)
{
	if (q->counter == -1)
	{
		return 1;
	}
	return 0;
}
// Handles the request of adding a new element into select queue
void enqueue(struct NQueue *q, int selection, int data)
{
	if (selection < 0 || selection >= q->part)
	{
		// When given queue is out of range
		return;
	}
	if (isFull(q) == 1)
	{
		printf("\n Queue is Full \n");
	}
	else
	{
		int location = q->next[q->counter];
		if (isEmpty(q, selection) == 1)
		{
			// First element of queue
			q->front[selection] = q->counter;
			q->tail[selection] = q->counter;
		}
		else
		{
			q->next[q->tail[selection]] = q->counter;
			q->tail[selection] = q->counter;
		}
		q->data[q->counter] = data;
		q->next[q->counter] = -1;
		q->counter = location;
	}
}
// Handles the request of remove selected queue element
int dequeue(struct NQueue *q, int selection)
{
	if (selection < 0 || selection >= q->part)
	{
		// When given queue is out of range
		return -1;
	}
	if (isEmpty(q, selection) == 1)
	{
		printf("\n Queue is Empty \n");
		return -1;
	}
	else
	{
		// Get the removed element location
		int location = q->front[selection];
		// Get the removed element
		int item = q->data[q->front[selection]];
		q->data[q->front[selection]] = 0; // reset data
		// Front is move to next element of queue
		q->front[selection] = q->next[location];
		// Set empty location in remove element
		q->next[location] = q->counter;
		// Set counter to current empty location
		q->counter = location;
		return item;
	}
}
// Display queue elements
void printQueue(struct NQueue *q)
{
	int location = 0;
	for (int i = 0; i < q->part; ++i)
	{
		printf("\n Queue %d : ", i);
		// Select Queue
		location = q->front[i];
		while (location != -1)
		{
			printf(" %d", q->data[location]);
			location = q->next[location];
		}
	}
}
int main(int argc, char
	const *argv[])
{
	struct NQueue *q = makeQueue(15, 4);
	// Add element in queue using random queue selection
	// Put data in queue-0
	enqueue(q, 0, 5);
	// Put data in queue-1
	enqueue(q, 1, 10);
	// Put data in queue-2
	enqueue(q, 2, 20);
	// Put data in queue-3
	enqueue(q, 3, 30);
	enqueue(q, 3, 19);
	// Put data in queue-0
	enqueue(q, 0, 15);
	enqueue(q, 0, 25);
	// Put data in queue-3
	enqueue(q, 3, 60);
	enqueue(q, 3, 9);
	enqueue(q, 3, 3);
	// Put data in queue-2
	enqueue(q, 2, 8);
	enqueue(q, 2, 45);
	printQueue(q);
	// Perform remove operation
	printf("\n Remove element of Queue %d is : %d", 0, dequeue(q, 0));
	printf("\n Remove element of Queue %d is : %d", 0, dequeue(q, 0));
	printf("\n Remove element of Queue %d is : %d", 3, dequeue(q, 3));
	printf("\n Remove element of Queue %d is : %d", 1, dequeue(q, 1));
	printQueue(q);
	return 0;
}

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 :
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3
/*
  Java Program for
  Efficiently implement n queues in a single array
*/
class NQueue
{
	public int element;
	public int part;
	public int []data;
	public int []front;
	public int []tail;
	public int []next;
	public int counter;
	public NQueue(int element, int part)
	{
		this.element = element;
		this.part = part;
		this.counter = 0;
		// Create memory of queue elements
		this.data = new int[element];
		this.next = new int[element];
		this.front = new int[part];
		this.tail = new int[part];
		int i = 0;
		// Set the initial value of front and tail of queue
		for (i = 0; i < part; ++i)
		{
			this.front[i] = -1;
			this.tail[i] = -1;
		}
		// Set next and data value
		for (i = 0; i < element - 1; ++i)
		{
			this.data[i] = 0;
			this.next[i] = i + 1;
		}
		this.next[element - 1] = -1;
		this.data[element - 1] = 0;
	}
	// Determine that given queue is empty or not
	public boolean isEmpty(int selection)
	{
		return this.front[selection] == -1;
	}
	// Determine that given queue is full or not
	public boolean isFull()
	{
		if (this.counter == -1)
		{
			return true;
		}
		return false;
	}
	// Handles the request of adding a new element into select queue
	public void enqueue(int selection, int data)
	{
		if (selection < 0 || selection >= this.part)
		{
			// When given queue is out of range
			return;
		}
		if (this.isFull() == true)
		{
			System.out.print("\n Queue is Full \n");
		}
		else
		{
			int location = this.next[this.counter];
			if (this.isEmpty(selection) == true)
			{
				// First element of queue
				this.front[selection] = this.counter;
				this.tail[selection] = this.counter;
			}
			else
			{
				this.next[this.tail[selection]] = this.counter;
				this.tail[selection] = this.counter;
			}
			this.data[this.counter] = data;
			this.next[this.counter] = -1;
			this.counter = location;
		}
	}
	// Handles the request of remove selected queue element
	public int dequeue(int selection)
	{
		if (selection < 0 || selection >= this.part)
		{
			// When given queue is out of range
			return -1;
		}
		else if (this.isEmpty(selection) == true)
		{
			System.out.print("\n Queue is Empty \n");
		}
		else
		{
			// Get the removed element location
			int location = this.front[selection];
			// Get the removed element
			int item = this.data[this.front[selection]];
			this.data[this.front[selection]] = 0;
			// reset data
			// Front is move to next element of queue
			this.front[selection] = this.next[location];
			// Set empty location in remove element
			this.next[location] = this.counter;
			// Set counter to current empty location
			this.counter = location;
			return item;
		}
		return -1;
	}
}
public class Implementation
{
	// Display queue elements
	public void printQueue(NQueue q)
	{
		int location = 0;
		for (int i = 0; i < q.part; ++i)
		{
			System.out.print("\n Queue " + i + " : ");
			// Select Queue
			location = q.front[i];
			while (location != -1)
			{
				System.out.print(" " + q.data[location]);
				location = q.next[location];
			}
		}
	}
	public static void main(String[] args)
	{
		NQueue q = new NQueue(15, 4);
		Implementation task = new Implementation();
		// Add element in queue using random queue selection
		// Put data in queue-0
		q.enqueue(0, 5);
		// Put data in queue-1
		q.enqueue(1, 10);
		// Put data in queue-2
		q.enqueue(2, 20);
		// Put data in queue-3
		q.enqueue(3, 30);
		q.enqueue(3, 19);
		// Put data in queue-0
		q.enqueue(0, 15);
		q.enqueue(0, 25);
		// Put data in queue-3
		q.enqueue(3, 60);
		q.enqueue(3, 9);
		q.enqueue(3, 3);
		// Put data in queue-2
		q.enqueue(2, 8);
		q.enqueue(2, 45);
		task.printQueue(q);
		// Perform remove operation
		System.out.print("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
		System.out.print("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
		System.out.print("\n Remove element of Queue " + 3 + " is : " + q.dequeue(3));
		System.out.print("\n Remove element of Queue " + 1 + " is : " + q.dequeue(1));
		task.printQueue(q);
	}
}

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 :
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3
// Include header file
#include <iostream>

using namespace std;
/*
  C++ Program for
  Efficiently implement n queues in a single array
*/
class NQueue
{
	public: int element;
	int part;
	int *data;
	int *front;
	int *tail;
	int *next;
	int counter;
	NQueue(int element, int part)
	{
		this->element = element;
		this->part = part;
		this->counter = 0;
		// Create memory of queue elements
		this->data = new int[element];
		this->next = new int[element];
		this->front = new int[part];
		this->tail = new int[part];
		int i = 0;
		// Set the initial value of front and tail of queue
		for (i = 0; i < part; ++i)
		{
			this->front[i] = -1;
			this->tail[i] = -1;
		}
		// Set next and data value
		for (i = 0; i < element - 1; ++i)
		{
			this->data[i] = 0;
			this->next[i] = i + 1;
		}
		this->next[element - 1] = -1;
		this->data[element - 1] = 0;
	}
	// Determine that given queue is empty or not
	bool isEmpty(int selection)
	{
		return this->front[selection] == -1;
	}
	// Determine that given queue is full or not
	bool isFull()
	{
		if (this->counter == -1)
		{
			return true;
		}
		return false;
	}
	// Handles the request of adding a new element into select queue
	void enqueue(int selection, int data)
	{
		// When given queue is out of range
		if (selection < 0 || selection >= this->part)
		{
			return;
		}
		if (this->isFull() == true)
		{
			cout << "\n Queue is Full \n";
		}
		else
		{
			int location = this->next[this->counter];
			if (this->isEmpty(selection) == true)
			{
				// First element of queue
				this->front[selection] = this->counter;
				this->tail[selection] = this->counter;
			}
			else
			{
				this->next[this->tail[selection]] = this->counter;
				this->tail[selection] = this->counter;
			}
			this->data[this->counter] = data;
			this->next[this->counter] = -1;
			this->counter = location;
		}
	}
	// Handles the request of remove selected queue element
	int dequeue(int selection)
	{
		if (selection < 0 || selection >= this->part)
		{
			// When given queue is out of range
			return -1;
		}
		else if (this->isEmpty(selection) == true)
		{
			cout << "\n Queue is Empty \n";
		}
		else
		{
			// Get the removed element location
			int location = this->front[selection];
			// Get the removed element
			int item = this->data[this->front[selection]];
			this->data[this->front[selection]] = 0;
			// reset data
			// Front is move to next element of queue
			this->front[selection] = this->next[location];
			// Set empty location in remove element
			this->next[location] = this->counter;
			// Set counter to current empty location
			this->counter = location;
			return item;
		}
		return -1;
	}
};
class Implementation
{
	public:
		// Display queue elements
		void printQueue(NQueue q)
		{
			int location = 0;
			for (int i = 0; i < q.part; ++i)
			{
				cout << "\n Queue " << i << " : ";
				// Select Queue
				location = q.front[i];
				while (location != -1)
				{
					cout << " " << q.data[location];
					location = q.next[location];
				}
			}
		}
};
int main()
{
	NQueue q = NQueue(15, 4);
	Implementation task = Implementation();
	// Add element in queue using random queue selection
	// Put data in queue-0
	q.enqueue(0, 5);
	// Put data in queue-1
	q.enqueue(1, 10);
	// Put data in queue-2
	q.enqueue(2, 20);
	// Put data in queue-3
	q.enqueue(3, 30);
	q.enqueue(3, 19);
	// Put data in queue-0
	q.enqueue(0, 15);
	q.enqueue(0, 25);
	// Put data in queue-3
	q.enqueue(3, 60);
	q.enqueue(3, 9);
	q.enqueue(3, 3);
	// Put data in queue-2
	q.enqueue(2, 8);
	q.enqueue(2, 45);
	task.printQueue(q);
	// Perform remove operation
	cout << "\n Remove element of Queue " << 0 << " is : " << q.dequeue(0);
	cout << "\n Remove element of Queue " << 0 << " is : " << q.dequeue(0);
	cout << "\n Remove element of Queue " << 3 << " is : " << q.dequeue(3);
	cout << "\n Remove element of Queue " << 1 << " is : " << q.dequeue(1);
	task.printQueue(q);
	return 0;
}

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 :
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3
// Include namespace system
using System;
/*
  C# Program for
  Efficiently implement n queues in a single array
*/
public class NQueue
{
	public int element;
	public int part;
	public int[] data;
	public int[] front;
	public int[] tail;
	public int[] next;
	public int counter;
	public NQueue(int element, int part)
	{
		this.element = element;
		this.part = part;
		this.counter = 0;
		// Create memory of queue elements
		this.data = new int[element];
		this.next = new int[element];
		this.front = new int[part];
		this.tail = new int[part];
		int i = 0;
		// Set the initial value of front and tail of queue
		for (i = 0; i < part; ++i)
		{
			this.front[i] = -1;
			this.tail[i] = -1;
		}
		// Set next and data value
		for (i = 0; i < element - 1; ++i)
		{
			this.data[i] = 0;
			this.next[i] = i + 1;
		}
		this.next[element - 1] = -1;
		this.data[element - 1] = 0;
	}
	// Determine that given queue is empty or not
	public Boolean isEmpty(int selection)
	{
		return this.front[selection] == -1;
	}
	// Determine that given queue is full or not
	public Boolean isFull()
	{
		if (this.counter == -1)
		{
			return true;
		}
		return false;
	}
	// Handles the request of adding a new element into select queue
	public void enqueue(int selection, int data)
	{
		// When given queue is out of range
		if (selection < 0 || selection >= this.part)
		{
			return;
		}
		if (this.isFull() == true)
		{
			Console.Write("\n Queue is Full \n");
		}
		else
		{
			int location = this.next[this.counter];
			if (this.isEmpty(selection) == true)
			{
				// First element of queue
				this.front[selection] = this.counter;
				this.tail[selection] = this.counter;
			}
			else
			{
				this.next[this.tail[selection]] = this.counter;
				this.tail[selection] = this.counter;
			}
			this.data[this.counter] = data;
			this.next[this.counter] = -1;
			this.counter = location;
		}
	}
	// Handles the request of remove selected queue element
	public int dequeue(int selection)
	{
		if (selection < 0 || selection >= this.part)
		{
			// When given queue is out of range
			return -1;
		}
		else if (this.isEmpty(selection) == true)
		{
			Console.Write("\n Queue is Empty \n");
		}
		else
		{
			// Get the removed element location
			int location = this.front[selection];
			// Get the removed element
			int item = this.data[this.front[selection]];
			this.data[this.front[selection]] = 0;
			// reset data
			// Front is move to next element of queue
			this.front[selection] = this.next[location];
			// Set empty location in remove element
			this.next[location] = this.counter;
			// Set counter to current empty location
			this.counter = location;
			return item;
		}
		return -1;
	}
}
public class Implementation
{
	// Display queue elements
	public void printQueue(NQueue q)
	{
		int location = 0;
		for (int i = 0; i < q.part; ++i)
		{
			Console.Write("\n Queue " + i + " : ");
			// Select Queue
			location = q.front[i];
			while (location != -1)
			{
				Console.Write(" " + q.data[location]);
				location = q.next[location];
			}
		}
	}
	public static void Main(String[] args)
	{
		NQueue q = new NQueue(15, 4);
		Implementation task = new Implementation();
		// Add element in queue using random queue selection
		// Put data in queue-0
		q.enqueue(0, 5);
		// Put data in queue-1
		q.enqueue(1, 10);
		// Put data in queue-2
		q.enqueue(2, 20);
		// Put data in queue-3
		q.enqueue(3, 30);
		q.enqueue(3, 19);
		// Put data in queue-0
		q.enqueue(0, 15);
		q.enqueue(0, 25);
		// Put data in queue-3
		q.enqueue(3, 60);
		q.enqueue(3, 9);
		q.enqueue(3, 3);
		// Put data in queue-2
		q.enqueue(2, 8);
		q.enqueue(2, 45);
		task.printQueue(q);
		// Perform remove operation
		Console.Write("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
		Console.Write("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
		Console.Write("\n Remove element of Queue " + 3 + " is : " + q.dequeue(3));
		Console.Write("\n Remove element of Queue " + 1 + " is : " + q.dequeue(1));
		task.printQueue(q);
	}
}

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 :
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3
<?php
/*
  Php Program for
  Efficiently implement n queues in a single array
*/
class NQueue
{
	public $element;
	public $part;
	public $data;
	public $front;
	public $tail;
	public $next;
	public $counter;

	function __construct($element, $part)
	{
		$this->element = $element;
		$this->part = $part;
		$this->counter = 0;
		// Create memory of queue elements
		$this->data = array_fill(0, $element, 0);
		$this->next = array_fill(0, $element, 0);
		$this->front = array_fill(0, $part, 0);
		$this->tail = array_fill(0, $part, 0);
		$i = 0;
		// Set the initial value of front and tail of queue
		for ($i = 0; $i < $part; ++$i)
		{
			$this->front[$i] = -1;
			$this->tail[$i] = -1;
		}
		// Set next and data value
		for ($i = 0; $i < $element - 1; ++$i)
		{
			$this->next[$i] = $i + 1;
		}
		$this->next[$element - 1] = -1;
	}
	// Determine that given queue is empty or not
	public	function isEmpty($selection)
	{
		return $this->front[$selection] == -1;
	}
	// Determine that given queue is full or not
	public	function isFull()
	{
		if ($this->counter == -1)
		{
			return true;
		}
		return false;
	}
	// Handles the request of adding a new element into select queue
	public	function enqueue($selection, $data)
	{
		// When given queue is out of range
		if ($selection < 0 || $selection >= $this->part)
		{
			return;
		}
		if ($this->isFull() == true)
		{
			echo "\n Queue is Full \n";
		}
		else
		{
			$location = $this->next[$this->counter];
			if ($this->isEmpty($selection) == true)
			{
				// First element of queue
				$this->front[$selection] = $this->counter;
				$this->tail[$selection] = $this->counter;
			}
			else
			{
				$this->next[$this->tail[$selection]] = $this->counter;
				$this->tail[$selection] = $this->counter;
			}
			$this->data[$this->counter] = $data;
			$this->next[$this->counter] = -1;
			$this->counter = $location;
		}
	}
	// Handles the request of remove selected queue element
	public	function dequeue($selection)
	{
		if ($selection < 0 || $selection >= $this->part)
		{
			// When given queue is out of range
			return -1;
		}
		else if ($this->isEmpty($selection) == true)
		{
			echo "\n Queue is Empty \n";
		}
		else
		{
			// Get the removed element location
			$location = $this->front[$selection];
			// Get the removed element
			$item = $this->data[$this->front[$selection]];
			$this->data[$this->front[$selection]] = 0;
			// reset data
			// Front is move to next element of queue
			$this->front[$selection] = $this->next[$location];
			// Set empty location in remove element
			$this->next[$location] = $this->counter;
			// Set counter to current empty location
			$this->counter = $location;
			return $item;
		}
		return -1;
	}
}
class Implementation
{
	// Display queue elements
	public	function printQueue($q)
	{
		$location = 0;
		for ($i = 0; $i < $q->part; ++$i)
		{
			echo "\n Queue ". $i ." : ";
			// Select Queue
			$location = $q->front[$i];
			while ($location != -1)
			{
				echo " ". $q->data[$location];
				$location = $q->next[$location];
			}
		}
	}
}

function main()
{
	$q = new NQueue(15, 4);
	$task = new Implementation();
	// Add element in queue using random queue selection
	// Put data in queue-0
	$q->enqueue(0, 5);
	// Put data in queue-1
	$q->enqueue(1, 10);
	// Put data in queue-2
	$q->enqueue(2, 20);
	// Put data in queue-3
	$q->enqueue(3, 30);
	$q->enqueue(3, 19);
	// Put data in queue-0
	$q->enqueue(0, 15);
	$q->enqueue(0, 25);
	// Put data in queue-3
	$q->enqueue(3, 60);
	$q->enqueue(3, 9);
	$q->enqueue(3, 3);
	// Put data in queue-2
	$q->enqueue(2, 8);
	$q->enqueue(2, 45);
	$task->printQueue($q);
	// Perform remove operation
	echo "\n Remove element of Queue ". 0 ." is : ". $q->dequeue(0);
	echo "\n Remove element of Queue ". 0 ." is : ". $q->dequeue(0);
	echo "\n Remove element of Queue ". 3 ." is : ". $q->dequeue(3);
	echo "\n Remove element of Queue ". 1 ." is : ". $q->dequeue(1);
	$task->printQueue($q);
}
main();

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 :
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3
/*
  Node Js Program for
  Efficiently implement n queues in a single array
*/
class NQueue
{
	constructor(element, part)
	{
		this.element = element;
		this.part = part;
		this.counter = 0;
		// Create memory of queue elements
		this.data = Array(element).fill(0);
		this.next = Array(element).fill(0);
		this.front = Array(part).fill(-1);
		this.tail = Array(part).fill(-1);
		var i = 0;
	
		// Set next and data value
		for (i = 0; i < element - 1; ++i)
		{
			this.next[i] = i + 1;
		}
		this.next[element - 1] = -1;
	}
	// Determine that given queue is empty or not
	isEmpty(selection)
	{
		return this.front[selection] == -1;
	}
	// Determine that given queue is full or not
	isFull()
	{
		if (this.counter == -1)
		{
			return true;
		}
		return false;
	}
	// Handles the request of adding a new element into select queue
	enqueue(selection, data)
	{
		// When given queue is out of range
		if (selection < 0 || selection >= this.part)
		{
			return;
		}
		if (this.isFull() == true)
		{
			process.stdout.write("\n Queue is Full \n");
		}
		else
		{
			var location = this.next[this.counter];
			if (this.isEmpty(selection) == true)
			{
				// First element of queue
				this.front[selection] = this.counter;
				this.tail[selection] = this.counter;
			}
			else
			{
				this.next[this.tail[selection]] = this.counter;
				this.tail[selection] = this.counter;
			}
			this.data[this.counter] = data;
			this.next[this.counter] = -1;
			this.counter = location;
		}
	}
	// Handles the request of remove selected queue element
	dequeue(selection)
	{
		if (selection < 0 || selection >= this.part)
		{
			// When given queue is out of range
			return -1;
		}
		else if (this.isEmpty(selection) == true)
		{
			process.stdout.write("\n Queue is Empty \n");
		}
		else
		{
			// Get the removed element location
			var location = this.front[selection];
			// Get the removed element
			var item = this.data[this.front[selection]];
			this.data[this.front[selection]] = 0;
			// reset data
			// Front is move to next element of queue
			this.front[selection] = this.next[location];
			// Set empty location in remove element
			this.next[location] = this.counter;
			// Set counter to current empty location
			this.counter = location;
			return item;
		}
		return -1;
	}
}
class Implementation
{
	// Display queue elements
	printQueue(q)
	{
		var location = 0;
		for (var i = 0; i < q.part; ++i)
		{
			process.stdout.write("\n Queue " + i + " : ");
			// Select Queue
			location = q.front[i];
			while (location != -1)
			{
				process.stdout.write(" " + q.data[location]);
				location = q.next[location];
			}
		}
	}
}

function main()
{
	var q = new NQueue(15, 4);
	var task = new Implementation();
	// Add element in queue using random queue selection
	// Put data in queue-0
	q.enqueue(0, 5);
	// Put data in queue-1
	q.enqueue(1, 10);
	// Put data in queue-2
	q.enqueue(2, 20);
	// Put data in queue-3
	q.enqueue(3, 30);
	q.enqueue(3, 19);
	// Put data in queue-0
	q.enqueue(0, 15);
	q.enqueue(0, 25);
	// Put data in queue-3
	q.enqueue(3, 60);
	q.enqueue(3, 9);
	q.enqueue(3, 3);
	// Put data in queue-2
	q.enqueue(2, 8);
	q.enqueue(2, 45);
	task.printQueue(q);
	// Perform remove operation
	process.stdout.write("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
	process.stdout.write("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
	process.stdout.write("\n Remove element of Queue " + 3 + " is : " + q.dequeue(3));
	process.stdout.write("\n Remove element of Queue " + 1 + " is : " + q.dequeue(1));
	task.printQueue(q);
}
main();

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 :
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3
#   Python 3 Program for
#   Efficiently implement n queues in a single array

class NQueue :
	
	def __init__(self, element, part) :
		self.element = element
		self.part = part
		self.counter = 0
		#  Create memory of queue elements
		self.data = [0] * (element)
		self.next = [0] * (element)
		self.front = [-1] * (part)
		self.tail = [-1] * (part)
		i = 0
		#  Set next and data value
		while (i < element - 1) :
			self.next[i] = i + 1
			i += 1
		
		self.next[element - 1] = -1
	
	#  Determine that given queue is empty or not
	def isEmpty(self, selection) :
		return self.front[selection] == -1
	
	#  Determine that given queue is full or not
	def isFull(self) :
		if (self.counter == -1) :
			return True
		
		return False
	
	#  Handles the request of adding a new element into select queue
	def enqueue(self, selection, data) :
		#  When given queue is out of range
		if (selection < 0 or selection >= self.part) :
			return
		
		if (self.isFull() == True) :
			print("\n Queue is Full ")
		else :
			location = self.next[self.counter]
			if (self.isEmpty(selection) == True) :
				#  First element of queue
				self.front[selection] = self.counter
				self.tail[selection] = self.counter
			else :
				self.next[self.tail[selection]] = self.counter
				self.tail[selection] = self.counter
			
			self.data[self.counter] = data
			self.next[self.counter] = -1
			self.counter = location
		
	
	#  Handles the request of remove selected queue element
	def dequeue(self, selection) :
		if (selection < 0 or selection >= self.part) :
			#  When given queue is out of range
			return -1
		
		elif(self.isEmpty(selection) == True) :
			print("\n Queue is Empty ")
		else :
			#  Get the removed element location
			location = self.front[selection]
			#  Get the removed element
			item = self.data[self.front[selection]]
			self.data[self.front[selection]] = 0
			#  reset data
			#  Front is move to next element of queue
			self.front[selection] = self.next[location]
			#  Set empty location in remove element
			self.next[location] = self.counter
			#  Set counter to current empty location
			self.counter = location
			return item
		
		return -1
	

class Implementation :
	#  Display queue elements
	def printQueue(self, q) :
		location = 0
		i = 0
		while (i < q.part) :
			print("\n Queue ", i ," : ", end = "")
			#  Select Queue
			location = q.front[i]
			while (location != -1) :
				print(" ", q.data[location], end = "")
				location = q.next[location]
			
			i += 1
		
	

def main() :
	q = NQueue(15, 4)
	task = Implementation()
	#  Add element in queue using random queue selection
	#  Put data in queue-0
	q.enqueue(0, 5)
	#  Put data in queue-1
	q.enqueue(1, 10)
	#  Put data in queue-2
	q.enqueue(2, 20)
	#  Put data in queue-3
	q.enqueue(3, 30)
	q.enqueue(3, 19)
	#  Put data in queue-0
	q.enqueue(0, 15)
	q.enqueue(0, 25)
	#  Put data in queue-3
	q.enqueue(3, 60)
	q.enqueue(3, 9)
	q.enqueue(3, 3)
	#  Put data in queue-2
	q.enqueue(2, 8)
	q.enqueue(2, 45)
	task.printQueue(q)
	#  Perform remove operation
	print("\n Remove element of Queue ", 0 ," is : ", q.dequeue(0), end = "")
	print("\n Remove element of Queue ", 0 ," is : ", q.dequeue(0), end = "")
	print("\n Remove element of Queue ", 3 ," is : ", q.dequeue(3), end = "")
	print("\n Remove element of Queue ", 1 ," is : ", q.dequeue(1), end = "")
	task.printQueue(q)

if __name__ == "__main__": main()

Output

 Queue  0  :   5  15  25
 Queue  1  :   10
 Queue  2  :   20  8  45
 Queue  3  :   30  19  60  9  3
 Remove element of Queue  0  is :  5
 Remove element of Queue  0  is :  15
 Remove element of Queue  3  is :  30
 Remove element of Queue  1  is :  10
 Queue  0  :   25
 Queue  1  :
 Queue  2  :   20  8  45
 Queue  3  :   19  60  9  3
#   Ruby Program for
#   Efficiently implement n queues in a single array

class NQueue  
	# Define the accessor and reader of class NQueue  
	attr_reader :element, :part, :data, :front, :tail, :next, :counter
	attr_accessor :element, :part, :data, :front, :tail, :next, :counter
 
	
	def initialize(element, part) 
		self.element = element
		self.part = part
		self.counter = 0
		#  Create memory of queue elements
		self.data = Array.new(element) {0}
		self.next = Array.new(element) {0}
		self.front = Array.new(part) {-1}
		self.tail = Array.new(part) {-1}
		i = 0
		#  Set next and data value
		while (i < element - 1) 
			self.next[i] = i + 1
			i += 1
		end

		self.next[element - 1] = -1
	end

	#  Determine that given queue is empty or not
	def isEmpty(selection) 
		return self.front[selection] == -1
	end

	#  Determine that given queue is full or not
	def isFull() 
		if (self.counter == -1) 
			return true
		end

		return false
	end

	#  Handles the request of adding a new element into select queue
	def enqueue(selection, data) 
		#  When given queue is out of range
		if (selection < 0 || selection >= self.part) 
			return
		end

		if (self.isFull() == true) 
			print("\n Queue is Full \n")
		else 
			location = self.next[self.counter]
			if (self.isEmpty(selection) == true) 
				#  First element of queue
				self.front[selection] = self.counter
				self.tail[selection] = self.counter
			else 
				self.next[self.tail[selection]] = self.counter
				self.tail[selection] = self.counter
			end

			self.data[self.counter] = data
			self.next[self.counter] = -1
			self.counter = location
		end

	end

	#  Handles the request of remove selected queue element
	def dequeue(selection) 
		if (selection < 0 || selection >= self.part) 
			#  When given queue is out of range
			return -1
		elsif(self.isEmpty(selection) == true) 
			print("\n Queue is Empty \n")
		else 
			#  Get the removed element location
			location = self.front[selection]
			#  Get the removed element
			item = self.data[self.front[selection]]
			self.data[self.front[selection]] = 0
			#  reset data
			#  Front is move to next element of queue
			self.front[selection] = self.next[location]
			#  Set empty location in remove element
			self.next[location] = self.counter
			#  Set counter to current empty location
			self.counter = location
			return item
		end

		return -1
	end

end

class Implementation 
	#  Display queue elements
	def printQueue(q) 
		location = 0
		i = 0
		while (i < q.part) 
			print("\n Queue ", i ," : ")
			#  Select Queue
			location = q.front[i]
			while (location != -1) 
				print(" ", q.data[location])
				location = q.next[location]
			end

			i += 1
		end

	end

end

def main() 
	q = NQueue.new(15, 4)
	task = Implementation.new()
	#  Add element in queue using random queue selection
	#  Put data in queue-0
	q.enqueue(0, 5)
	#  Put data in queue-1
	q.enqueue(1, 10)
	#  Put data in queue-2
	q.enqueue(2, 20)
	#  Put data in queue-3
	q.enqueue(3, 30)
	q.enqueue(3, 19)
	#  Put data in queue-0
	q.enqueue(0, 15)
	q.enqueue(0, 25)
	#  Put data in queue-3
	q.enqueue(3, 60)
	q.enqueue(3, 9)
	q.enqueue(3, 3)
	#  Put data in queue-2
	q.enqueue(2, 8)
	q.enqueue(2, 45)
	task.printQueue(q)
	#  Perform remove operation
	print("\n Remove element of Queue ", 0 ," is : ", q.dequeue(0))
	print("\n Remove element of Queue ", 0 ," is : ", q.dequeue(0))
	print("\n Remove element of Queue ", 3 ," is : ", q.dequeue(3))
	print("\n Remove element of Queue ", 1 ," is : ", q.dequeue(1))
	task.printQueue(q)
end

main()

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 : 
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3
/*
  Scala Program for
  Efficiently implement n queues in a single array
*/
class NQueue(var element: Int , var part: Int , 
             var data: Array[Int] , var front: Array[Int] , 
  var tail: Array[Int] , var next: Array[Int] , var counter: Int)
{
	def this(element: Int, part: Int)
	{
        this(element, part, 
             Array.fill[Int](element)(0), 
             Array.fill[Int](part)(-1),
             Array.fill[Int](part)(-1), 
             Array.fill[Int](element)(0), 0);
		var i: Int = 0
		// Set next and data value
		while (i < element - 1)
		{
          	this.next(i) = i+1;
          	i += 1
		}
		this.next(element - 1) = -1;
	}
	// Determine that given queue is empty or not
	def isEmpty(selection: Int): Boolean = {
		return this.front(selection) == -1;
	}
	// Determine that given queue is full or not
	def isFull(): Boolean = {
		if (this.counter == -1)
		{
			return true;
		}
		return false;
	}
	// Handles the request of adding a new element into select queue
	def enqueue(selection: Int, data: Int): Unit = {
		// When given queue is out of range
		if (selection < 0 || selection >= this.part)
		{
			return;
		}
		if (this.isFull() == true)
		{
			print("\n Queue is Full \n");
		}
		else
		{
			var location: Int = this.next(this.counter);
			if (this.isEmpty(selection) == true)
			{
				// First element of queue
				this.front(selection) = this.counter;
				this.tail(selection) = this.counter;
			}
			else
			{
				this.next(this.tail(selection)) = this.counter;
				this.tail(selection) = this.counter;
			}
			this.data(this.counter) = data;
			this.next(this.counter) = -1;
			this.counter = location;
		}
	}
	// Handles the request of remove selected queue element
	def dequeue(selection: Int): Int = {
		if (selection < 0 || selection >= this.part)
		{
			// When given queue is out of range
			return -1;
		}
		else if (this.isEmpty(selection) == true)
		{
			print("\n Queue is Empty \n");
		}
		else
		{
			// Get the removed element location
			var location: Int = this.front(selection);
			// Get the removed element
			var item: Int = this.data(this.front(selection));
			this.data(this.front(selection)) = 0;
			// reset data
			// Front is move to next element of queue
			this.front(selection) = this.next(location);
			// Set empty location in remove element
			this.next(location) = this.counter;
			// Set counter to current empty location
			this.counter = location;
			return item;
		}
		return -1;
	}
}
class Implementation
{
	// Display queue elements
	def printQueue(q: NQueue): Unit = {
		var location: Int = 0;
		var i: Int = 0;
		while (i < q.part)
		{
			print("\n Queue " + i + " : ");
			// Select Queue
			location = q.front(i);
			while (location != -1)
			{
				print(" " + q.data(location));
				location = q.next(location);
			}
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var q: NQueue = new NQueue(15, 4);
		var task: Implementation = new Implementation();
		// Add element in queue using random queue selection
		// Put data in queue-0
		q.enqueue(0, 5);
		// Put data in queue-1
		q.enqueue(1, 10);
		// Put data in queue-2
		q.enqueue(2, 20);
		// Put data in queue-3
		q.enqueue(3, 30);
		q.enqueue(3, 19);
		// Put data in queue-0
		q.enqueue(0, 15);
		q.enqueue(0, 25);
		// Put data in queue-3
		q.enqueue(3, 60);
		q.enqueue(3, 9);
		q.enqueue(3, 3);
		// Put data in queue-2
		q.enqueue(2, 8);
		q.enqueue(2, 45);
		task.printQueue(q);
		// Perform remove operation
		print("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
		print("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
		print("\n Remove element of Queue " + 3 + " is : " + q.dequeue(3));
		print("\n Remove element of Queue " + 1 + " is : " + q.dequeue(1));
		task.printQueue(q);
	}
}

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 :
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3
/*
  Swift 4 Program for
  Efficiently implement n queues in a single array
*/
class NQueue
{
	var element: Int;
	var part: Int;
	var data: [Int];
	var front: [Int];
	var tail: [Int];
	var next: [Int];
	var counter: Int;
	init(_ element: Int, _ part: Int)
	{
		self.element = element;
		self.part = part;
		self.counter = 0;
		// Create memory of queue elements
		self.data = Array(repeating: 0, count: element);
		self.next = Array(repeating: 0, count: element);
		self.front = Array(repeating: -1, count: part);
		self.tail = Array(repeating: -1, count: part);
		var i: Int = 0;
		// Set next and data value
		while (i < element - 1)
		{
			self.next[i] = i + 1;
			i += 1;
		}
		self.next[element - 1] = -1;
	}
	// Determine that given queue is empty or not
	func isEmpty(_ selection: Int)->Bool
	{
		return self.front[selection] == -1;
	}
	// Determine that given queue is full or not
	func isFull()->Bool
	{
		if (self.counter == -1)
		{
			return true;
		}
		return false;
	}
	// Handles the request of adding a new element into select queue
	func enqueue(_ selection: Int, _ data: Int)
	{
		// When given queue is out of range
		if (selection < 0 || selection >= self.part)
		{
			return;
		}
		if (self.isFull() == true)
		{
			print("\n Queue is Full ");
		}
		else
		{
			let location: Int = self.next[self.counter];
			if (self.isEmpty(selection) == true)
			{
				// First element of queue
				self.front[selection] = self.counter;
				self.tail[selection] = self.counter;
			}
			else
			{
				self.next[self.tail[selection]] = self.counter;
				self.tail[selection] = self.counter;
			}
			self.data[self.counter] = data;
			self.next[self.counter] = -1;
			self.counter = location;
		}
	}
	// Handles the request of remove selected queue element
	func dequeue(_ selection: Int)->Int
	{
		if (selection < 0 || selection >= self.part)
		{
			// When given queue is out of range
			return -1;
		}
		else if (self.isEmpty(selection) == true)
		{
			print("\n Queue is Empty ");
		}
		else
		{
			// Get the removed element location
			let location: Int = self.front[selection];
			// Get the removed element
			let item: Int = self.data[self.front[selection]];
			self.data[self.front[selection]] = 0;
			// reset data
			// Front is move to next element of queue
			self.front[selection] = self.next[location];
			// Set empty location in remove element
			self.next[location] = self.counter;
			// Set counter to current empty location
			self.counter = location;
			return item;
		}
		return -1;
	}
}
class Implementation
{
	// Display queue elements
	func printQueue(_ q: NQueue? )
	{
		var location: Int = 0;
		var i: Int = 0;
		while (i < q!.part)
		{
			print("\n Queue ", i ," : ", terminator: "");
			// Select Queue
			location = q!.front[i];
			while (location  != -1)
			{
				print(" ", q!.data[location], terminator: "");
				location = q!.next[location];
			}
			i += 1;
		}
	}
}
func main()
{
	let q: NQueue = NQueue(15, 4);
	let task: Implementation = Implementation();
	// Add element in queue using random queue selection
	// Put data in queue-0
	q.enqueue(0, 5);
	// Put data in queue-1
	q.enqueue(1, 10);
	// Put data in queue-2
	q.enqueue(2, 20);
	// Put data in queue-3
	q.enqueue(3, 30);
	q.enqueue(3, 19);
	// Put data in queue-0
	q.enqueue(0, 15);
	q.enqueue(0, 25);
	// Put data in queue-3
	q.enqueue(3, 60);
	q.enqueue(3, 9);
	q.enqueue(3, 3);
	// Put data in queue-2
	q.enqueue(2, 8);
	q.enqueue(2, 45);
	task.printQueue(q);
	// Perform remove operation
	print("\n Remove element of Queue ", 0 ," is : ", q.dequeue(0), terminator: "");
	print("\n Remove element of Queue ", 0 ," is : ", q.dequeue(0), terminator: "");
	print("\n Remove element of Queue ", 3 ," is : ", q.dequeue(3), terminator: "");
	print("\n Remove element of Queue ", 1 ," is : ", q.dequeue(1), terminator: "");
	task.printQueue(q);
}
main();

Output

 Queue  0  :   5  15  25
 Queue  1  :   10
 Queue  2  :   20  8  45
 Queue  3  :   30  19  60  9  3
 Remove element of Queue  0  is :  5
 Remove element of Queue  0  is :  15
 Remove element of Queue  3  is :  30
 Remove element of Queue  1  is :  10
 Queue  0  :   25
 Queue  1  :
 Queue  2  :   20  8  45
 Queue  3  :   19  60  9  3
/*
  Kotlin Program for
  Efficiently implement n queues in a single array
*/
class NQueue
{
	var element: Int;
	var part: Int;
	var data: Array <Int> ;
	var front: Array <Int> ;
	var tail: Array <Int> ;
	var next: Array <Int> ;
	var counter: Int;
	constructor(element: Int, part: Int)
	{
		this.element = element;
		this.part = part;
		this.counter = 0;
		// Create memory of queue elements
		this.data = Array(element)
		{
			0
		};
		this.next = Array(element)
		{
			0
		};
		this.front = Array(part)
		{
			-1
		};
		this.tail = Array(part)
		{
			-1
		};
		var i: Int = 0;
		// Set next and data value
		while (i < element - 1)
		{
			this.next[i] = i + 1;
			i += 1;
		}
		this.next[element - 1] = -1;
	}
	// Determine that given queue is empty or not
	fun isEmpty(selection: Int): Boolean
	{
		return this.front[selection] == -1;
	}
	// Determine that given queue is full or not
	fun isFull(): Boolean
	{
		if (this.counter == -1)
		{
			return true;
		}
		return false;
	}
	// Handles the request of adding a new element into select queue
	fun enqueue(selection: Int, data: Int): Unit
	{
		// When given queue is out of range
		if (selection < 0 || selection >= this.part)
		{
			return;
		}
		if (this.isFull() == true)
		{
			print("\n Queue is Full \n");
		}
		else
		{
			var location: Int = this.next[this.counter];
			if (this.isEmpty(selection) == true)
			{
				// First element of queue
				this.front[selection] = this.counter;
				this.tail[selection] = this.counter;
			}
			else
			{
				this.next[this.tail[selection]] = this.counter;
				this.tail[selection] = this.counter;
			}
			this.data[this.counter] = data;
			this.next[this.counter] = -1;
			this.counter = location;
		}
	}
	// Handles the request of remove selected queue element
	fun dequeue(selection: Int): Int
	{
		if (selection < 0 || selection >= this.part)
		{
			
			// When given queue is out of range
			return -1;
		}
		else if (this.isEmpty(selection) == true)
		{
			print("\n Queue is Empty \n");
		}
		else
		{
			// Get the removed element location
			var location: Int = this.front[selection];
			// Get the removed element
			var item: Int = this.data[this.front[selection]];
			this.data[this.front[selection]] = 0;
			// reset data
			// Front is move to next element of queue
			this.front[selection] = this.next[location];
			// Set empty location in remove element
			this.next[location] = this.counter;
			// Set counter to current empty location
			this.counter = location;
			return item;
		}
		return -1;
	}
}
class Implementation
{
	// Display queue elements
	fun printQueue(q: NQueue): Unit
	{
		var location: Int;
		var i: Int = 0;
		while (i < q.part)
		{
			print("\n Queue " + i + " : ");
			// Select Queue
			location = q.front[i];
			while (location != -1)
			{
				print(" " + q.data[location]);
				location = q.next[location];
			}
			i += 1;
		}
	}
}
fun main(args: Array < String > ): Unit
{
	var q: NQueue = NQueue(15, 4);
	var task: Implementation = Implementation();
	// Add element in queue using random queue selection
	// Put data in queue-0
	q.enqueue(0, 5);
	// Put data in queue-1
	q.enqueue(1, 10);
	// Put data in queue-2
	q.enqueue(2, 20);
	// Put data in queue-3
	q.enqueue(3, 30);
	q.enqueue(3, 19);
	// Put data in queue-0
	q.enqueue(0, 15);
	q.enqueue(0, 25);
	// Put data in queue-3
	q.enqueue(3, 60);
	q.enqueue(3, 9);
	q.enqueue(3, 3);
	// Put data in queue-2
	q.enqueue(2, 8);
	q.enqueue(2, 45);
	task.printQueue(q);
	// Perform remove operation
	print("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
	print("\n Remove element of Queue " + 0 + " is : " + q.dequeue(0));
	print("\n Remove element of Queue " + 3 + " is : " + q.dequeue(3));
	print("\n Remove element of Queue " + 1 + " is : " + q.dequeue(1));
	task.printQueue(q);
}

Output

 Queue 0 :  5 15 25
 Queue 1 :  10
 Queue 2 :  20 8 45
 Queue 3 :  30 19 60 9 3
 Remove element of Queue 0 is : 5
 Remove element of Queue 0 is : 15
 Remove element of Queue 3 is : 30
 Remove element of Queue 1 is : 10
 Queue 0 :  25
 Queue 1 :
 Queue 2 :  20 8 45
 Queue 3 :  19 60 9 3

Output Explanation

The code demonstrates the efficient implementation of multiple queues using a single array. It enqueues and dequeues elements from different queues and prints the resulting elements of all queues.

Time Complexity

The time complexity of enqueue and dequeue operations is O(1) since we are maintaining front, tail, and next pointers. The space complexity is also O(N), where N is the total number of elements across all queues. It's important to note that the space complexity of the next array is O(N), which can be significant if the number of elements is large.

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment





Categories
Relative Post