Implementation of Deque by Circular Array

Before going to the implementation of Deque using the circular array, first, let's understand what a queue is?

A queue is an orderly collection of items in which new items are added at one end, referred to as the "back", and current items are removed at the other end, referred to as the "front". When an element joins the queue, it begins at the back and works its way to the front, waiting for the next element to be removed. The queue's most recently added item must wait until the end of the collection. At the front is the object that has been in the collection the longest. FIFO, or first-in, first-out, is another name for this ordering approach. "First-come, first-served" is another term for it.

To regulate processes within a computer, operating systems use a variety of different queues. The next task is usually scheduled using a queuing method to run programs as rapidly as possible while serving as many people as possible. Also, keystrokes can sometimes outnumber the characters on the screen as we type, and this is because the computer is now occupied with other tasks. The keystrokes are queued in a buffer to be presented on the screen in the correct order later.

Enqueue is the process of adding an element to the back of the queue, and dequeue is the process of removing an element from the front. Other operations, such as a peek or front operation that returns the value of the next element to be dequeued without dequeuing it, may be permitted.

Now let's understand Deque. A deque or double-ended queue is an ordered group of items that functions similarly to a queue. It has two ends, a front and a back, and the items in the collection remain in place. The unrestrictive nature of adding and removing elements distinguishes a deque. New things can be added to the front or back of the house. Existing things can be removed from either end as well. It's worth noting that, while the Deque can mimic many of the properties of stacks and queues, it doesn't require the LIFO and FIFO orderings that those data structures enforce. It is up to you to use the addition and removal operations consistently. Here are the different operations that are supported by a deque data structure:

insertFront(x): The insertFront() function will insert an element x at the front of Deque. There is one parameter to the insertFront() function representing the data that we want to add to the front of the Deque data structure.
insertRear(x): The insertRear() function will insert an element x at the rear of Deque. There is one parameter to the insertRear() function representing the data that we want to add to the rear of the Deque data structure.
deleteFront(): The deleteFront() function will delete an element from the front of Deque
deleteRear(): The deleteRear() function will delete an element from the rear of Deque
getFront(): The getFront() function will return the element present at the front of Deque
getRear(): The getRear() function will return the element present at the rear of Deque
isEmpty(): The isEmpty() function will return whether or not the Deque is empty
isFull(): The isFull() function will return whether or not the Deque is full

Java Code

Now let's write a code in Java programming language to create a Deque data structure using a circular array.

// A sample Java program to create a Deque Data structure using a circular array in Java

import java.util.Scanner;

// A class named Deque is created that have all the functions of the Deque Data structure in it 
class Deque
{
	// a static final Integer variable named MAX is created and initialized with 100 that will represent the total maximum capacity of the Deque Data structure
	static final int MAX = 100;
	// An Integer array named arr is created that will be the circular array
	int arr[];
	// An Integer variable named front is created that will represent the front of the Deque Data structure
	int front;
	// An Integer variable named rear is created that will represent the rear of the Deque Data structure
	int rear;
	// An Integer variable named size is created that will represent the size of the Deque Data structure
	int size;
	
	// A constructor of the Deque is created that will be used to initialize various variables of the Deque class
	public Deque(int size)
	{
	
		// The arr array is initialized with the MAX value defined earlier
		arr = new int[MAX];
		front = -1;
		rear = 0;
		this.size = size;
	}

	// The isFull() function will return whether or not the Deque is full or not
	// If the capacity of the Deque is full, then it will return True, and if there is capacity remaining, False will be returned
	boolean isFull()
	{
		return ((front == 0 && rear == size-1)||
			front == rear+1);
	}

	// The isEmpty() function will return whether or not the Deque is empty
	boolean isEmpty ()
	{
		return (front == -1);
	}


	// The insertFront() function will insert an element x at the front of Deque. There is one parameter to the insertFront() function representing the data that we want to add to the front of the Deque data structure.
	void insertfront(int key)
	{
		// check whether Deque if full or not
		if (isFull())
		{
			System.out.println("Overflow");
			return;
		}

		// If queue is initially empty
		if (front == -1)
		{
			front = 0;
			rear = 0;
		}
		
		// front is at first position of queue
		else if (front == 0)
			front = size - 1 ;

		else // decrement front end by '1'
			front = front-1;

		// insert current element into Deque
		arr[front] = key ;
	}


	// The insertRear() function will  insert an element x at the rear of Deque. There is one parameter to the insertRear() function representing the data that we want to add to the rear of the Deque data structure.
	void insertrear(int key)
	{
		if (isFull())
		{
			System.out.println(" Overflow ");
			return;
		}

		// If queue is initially empty
		if (front == -1)
		{
			front = 0;
			rear = 0;
		}

		// rear is at last position of queue
		else if (rear == size-1)
			rear = 0;

		// increment rear end by '1'
		else
			rear = rear+1;
		
		// insert current element into Deque
		arr[rear] = key ;
	}


	// The deleteFront() function will delete an element from the front of Deque
	void deletefront()
	{
		// check whether Deque is empty or not
		if (isEmpty())
		{
			System.out.println("Queue Underflow\n");
			return ;
		}

		// Deque has only one element
		if (front == rear)
		{
			front = -1;
			rear = -1;
		}
		else
			// back to initial position
			if (front == size -1)
				front = 0;

			else // increment front by '1' to remove current
				// front value from Deque
				front = front+1;
	}

	// The deleteRear() function will delete an element from the rear of Deque
	void deleterear()
	{
		if (isEmpty())
		{
			System.out.println(" Underflow");
			return ;
		}

		// Deque has only one element
		if (front == rear)
		{
			front = -1;
			rear = -1;
		}
		else if (rear == 0)
			rear = size-1;
		else
			rear = rear-1;
	}

	// The getFront() function will return the element present at the front of Deque
	int getFront()
	{
		// check whether Deque is empty or not
		if (isEmpty())
		{
			System.out.println(" Underflow");
			return -1 ;
		}
		return arr[front];
	}

	// The getRear() function will return the element present at the rear of Deque
	int getRear()
	{
		// check whether Deque is empty or not
		if(isEmpty() || rear < 0)
		{
			System.out.println(" Underflow\n");
			return -1 ;
		}
		return arr[rear];
	}

	void printDeque(){
		for (int o :arr){
			if (o != 0)
				System.out.print(o + " ");
		}
		System.out.println();
	}


	// main function is written to call all the functionalities functions of the Deque Data structure written above
	public static void main(String[] args)
	{
		
		Deque dq = new Deque(5);
		Scanner sc = new Scanner(System.in);

		int data;
		int count = 0;
	  	char ch;

            // Do-while loop
            // Do part for performing actions
            do
            // Menu is displayed
            // Users enter 'y' to continue 'n' if
            // entered by user , the program terminates

            {
                  // Menu
                  // Display messages
                  System.out.println("Please Choose one of the Operations::");
                  System.out.println("1. To Insert Data at the Front of Deque.");
                  System.out.println("2. To Insert Data at the Rear of Deque.");
                  System.out.println("3. To Print Data from the Front of Deque.");
                  System.out.println("4. To Print Data from the Rear of Deque.");
                  System.out.println("5. To Delete Data from the Front of Deque.");
                  System.out.println("6. To Delete Data from the Rear of Deque.");
                  System.out.println("7. To print the Deque.");                 

                  int choice;
                  choice = sc.nextInt();

                  // Switch case
                  switch (choice) {

                  // Case 1
                  case 1:

                        System.out.println("Enter the data :\n");
                        data = sc.nextInt();
                        dq.insertfront(data);
                        // Display message
                        System.out.println("Data Added Successfully.\n");
                        // Break statement to terminate a case
                        break;

                   // Case 2
                  case 2:

                        System.out.println("Enter the data :\n");
                        data = sc.nextInt();
                        dq.insertrear(data);
                        // Display message
                        System.out.println("Data Added Successfully.\n");
                        // Break statement to terminate a case
                        break;


                   // Case 3
                  case 3:

                        System.out.println("Data at front:" + dq.getFront() + "\n");
                        break;

                  // Case 4
                  case 4:

                        System.out.println("Data at rear:" + dq.getRear() + "\n");
                        break;

                  // Case 5
                  case 5:

                        dq.deletefront();
                        System.out.println("Data deleted from the front.");
                        break;
                 
                 // Case 6
                  case 6:

                        dq.deleterear();
                        System.out.println("Data deleted from the rear.");
                        break;


                   // Case 7
                  case 7:

                        System.out.println("Data in Deque::");
                        dq.printDeque();
                        break;


                  default:
                        // Print statement
                        System.out.println("Please enter a valid option from the menu to proceed further.\n \n");
                        // Break statement
                        break;
                  }


                  System.out.println("\nType [N or n] to terminate the program.\nType [Y or y] to continue the program.\n");
                  sc.nextLine();
                  ch = sc.nextLine().charAt(0);
                  
            } while (!(ch == 'N' || ch == 'n'));

	}
}

Output:

The above code gives the following output:

Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
1
Enter the data:

10
Data Added Successfully.


Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
2
Enter the data :

25
Data Added Successfully.


Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
1
Enter the data :

45
Data Added Successfully.


Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
2
Enter the data :

60
Data Added Successfully.


Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
7
Data in Deque::
45 10 25 60 

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
3
Data at front:45


Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
4
Data at rear:60


Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
5
Data deleted from the front.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
7
Data in Deque::
10 25 60 

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
6
Data deleted from the rear.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data at the Front of Deque.
2. To Insert Data at the Rear of Deque.
3. To Print Data from the Front of Deque.
4. To Print Data from the Rear of Deque.
5. To Delete Data from the Front of Deque.
6. To Delete Data from the Rear of Deque.
7. To print the Deque.
7
Data in Deque::
10 25

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

n

In the above code, we have first created a Deque data structure and added into that Deque from both the ends using respective inserting functions for both the front and the rear end.

Once the data is successfully inserted into the Deque, the next step is to perform the delete operations at both ends of the deque data structure. There are two functions to delete data from both ends of the Deque.

After each operation, we have printed the contents of the deque data structure using the printDeque() function, which prints all the contents of the Deque beginning from the front and ending at the rear end of the Deque. And for creating the deque data, we have used the circular array.

Application

The work-stealing algorithm is an example of how a deque might be employed. [6] This technique is used to schedule tasks among many CPUs. For each processor, a separate deque with threads to be performed is kept. The processor obtains the first element from the Deque to start the next thread (using the "remove the first element" deque operation). If the current thread forks, the current thread is returned to the front of the Deque ("insert an element at the front"), and a new thread is started.

When one of the processors has completed the execution of its own threads (i.e., its Deque is empty), it can "steal" a thread from another processor by retrieving the final element from another processor's Deque ("remove the last element") and executing it. Intel's Threading Building Blocks (TBB) package uses the work-stealing mechanism for parallel programming.

Next TopicRotate Operation in Linked List

← prev next →