Question

Balment a la medicul Quoc that speciala a circular que has the following private data members and public member functions. The circular que simplemented using an atay. Your submission should consist of four separate files the three source code file header file.implementation file and main program or routine and the program otput. When making the submission, please do not submit it as a file Private data members: int the tray int current size oprema prinete the first met of the Note: It is a pointer to a dynamically allocated array le, using these keywords opres the lumber of dements in the indes representing the front of the que an index representing the back of the queue represents the capacity of the army int front int back int capacity: Circularqueue fint cap-10) This is a constructor which takes initial capacity cap as a parameter Note that front should be initialized to and back should be initialized to -CircularQueue 1) This is a de int get capacity cena: Returns the capacity of the int getSize() conta Return the case of the w bool larul) con Returns true if the queue is full current size capacity Oherwise, sturmfalme bool is repty conti Returns true if the queue is empty lie.current size -- 0) Oherwise, false Int geronta conati Returns front ote that front is minder int getBack() consta Returns back that back is minder void expand This double the capacity of the way void anquece(int vall Insert a give vale valinto the go. Note that the wis circular If the que is full, you should first call expand and then insert the valu val.

Answer 1

#include<iostream>
#include<stdlib.h>
using namespace std;

// Class CircularQueue definition
class CircularQueue
{
// an index representing front and back for the queue
int backIndex, frontIndex;

// Represents the capacity of the array
int capacity;
// Represents the actual number of elements in the queue
int currentSize;
// Array to store data
int *theArray;

public:
// Prototype of member functions
CircularQueue(int cap = 10);
~CircularQueue();
void enqueue(int);
int dequeue();
int getCapacity() const;
int getSize() const;
bool isEmpty() const;
bool isFull() const;
int getFront() const;
int getBack() const;
void displayqueue();
};// End of class

// Destructor
CircularQueue::~CircularQueue()
{
// Deletes the array
delete theArray;
// Initializes front and back index to -1
frontIndex = backIndex = -1;
// Initializes current size to 0
currentSize = 0;

}
// Parameterized constructor definition takes cap as parameter
CircularQueue::CircularQueue(int cap)
{
// Initializes front and back index to -1
frontIndex = backIndex = -1;
// Initializes current size to 0
currentSize = 0;
// Assigns parameter cap to data member capacity
capacity = cap;
// Dynamically allocates memory to pointer theArray of capacity parameter value cap
theArray = new int[cap];
}// End of parameterized constructor

// Function to return capacity of the circular queue
int CircularQueue::getCapacity() const
{
return capacity;
}// End of function

// Function to return current size of the circular queue
int CircularQueue::getSize() const
{
return currentSize;
}// End of function

// Function to return true if circular queue is empty otherwise returns false
bool CircularQueue::isEmpty() const
{
return (currentSize == 0);
}// End of function

// Function to return true if circular queue is full otherwise returns false
bool CircularQueue::isFull() const
{
return (currentSize == capacity);
}// End of function

// Function to return the front element
int CircularQueue::getFront() const
{
return theArray[frontIndex];
}// End of function

// Function to return the back element
int CircularQueue::getBack() const
{
return theArray[backIndex];
}// End of function

// Function to inset number to Circular Queue
void CircularQueue::enqueue(int value)
{
// Checks circular queue is full or not

// Checks if front index is zero and back index is capacity minus one
// or back index is equals to front index -1 module capacity minus one remainder
// Then display queue is full
if ((frontIndex == 0 && backIndex == capacity - 1) || (backIndex == (frontIndex - 1) % (capacity - 1)))
{
cout<<"\n Queue is full.";
return;
}// End of if condition

// Insert First Element
// Checks if front index is -1 no elements available in circular queue
else if (frontIndex == -1)
{
// Both front and back index is initializes to zero
frontIndex = backIndex = 0;
// Assigns value to the back index position of array theArray i.e., rear of the circular queue
theArray[backIndex] = value;
// Increase the current counter by one
currentSize++;
}// End of else if condition

// Last number to insert
// Checks if back index is equals to capacity -1 and front index is not zero
else if (backIndex == capacity - 1 && frontIndex != 0)
{
// Reset the back index to zero to point to beginning of the array
backIndex = 0;
// Assigns value to the back index position of array theArray i.e., rear of the circular queue
theArray[backIndex] = value;
// Increase the current counter by one
currentSize++;
}// End of else if condition

// Otherwise
else
{
// Increase the back index position by one to point to next index position
backIndex++;
// Assigns value to the back index position of array theArray i.e., rear of the circular queue
theArray[backIndex] = value;
// Increase the current counter by one
currentSize++;
}// End of else
}// End of function

// Function to delete element from Circular Queue
int CircularQueue::dequeue()
{
// Checks Circular Queue is empty or not

// Checks if front index is -1 then display circular queue is empty
if (frontIndex == -1)
{
cout<<"\n Queue is empty";
return INT_MIN;
}// End of if condition

// Otherwise assigns front index position data of array number to data
int data = theArray[frontIndex];
// Assigns -1 to front index position of the array number to -1
theArray[frontIndex] = -1;

// Decrease the current size by one
currentSize--;

// Only one number to delete

// Checks if front and back index value is same
if (frontIndex == backIndex)
{
// Reset the front and back index to -1 for empty circular queue
frontIndex = backIndex = -1;
}// End of if condition

// Last element to delete

// Otherwise checks if front index is equals to capacity -1 reset the front index to 0
// To point to beginning of the array
else if (frontIndex == capacity - 1)
frontIndex = 0;
// Otherwise increase the front index by one to point to next index position of the array
else
frontIndex++;

// Returns the deleted data
return data;
}// End of function

// Function displaying the elements of Circular Queue
void CircularQueue::displayqueue()
{
// Checks Circular Queue is empty or not

// Checks if front index is -1 then display circular queue is empty
if (frontIndex == -1)
{
cout<<"\n Queue is empty";
return;
}// End of if condition

cout<<"\n Elements in Circular Queue: ";

// Checks if back index value is greater than or equals to front index
if (backIndex >= frontIndex)
{
// Loops from front index to back index and displays the values
for (int c = frontIndex; c <= backIndex; c++)
cout<<theArray[c]<<" -> ";
}// End of if condition
// Otherwise
else
{
// Loops from front index to end of circular queue and displays the values
for (int c = frontIndex; c < capacity; c++)
cout<<theArray[c]<<" -> ";
// Loops from zero index to back index and displays the values
for (int c = 0; c <= backIndex; c++)
cout<<theArray[c]<<" -> ";
}// End else
}// End of function

// Function to display menu, accept user choice and returns it
int menu()
{
// To store user choice
int ch;
cout<<"\n\n ************************ Circular Queue Menu ************************";
// Displays menu
cout<<"\n\t 1 - Insert. \n\t 2 - Delete. \n\t 3 - Display. \n\t 4 - Check Empty. \n\t 5 - Check Full."
<<"\n\t 6 - Get Front Element. \n\t 7 - Get Back Element. \n\t 8 - Get Capacity \n\t 9 - Get Size \n\t 10 - Exit.";
// Accepts user choice
cout<<"\n\t\t What is your choice? ";
cin>>ch;
// Returns user choice
return ch;
}// End of function

// main function definition
int main()
{
// To store the size entered by the user
int si;
// To store the number entered by the user
int no;
// Accepts circular queue size from user
cout<<"\n Enter the size of the Circular Queue: ";
cin>>si;

// Creates an object using parameterized constructor
CircularQueue myqueue(si);

// Loops till user choice is not 4
do
{
// Calls the function to display menu
// Based on the return value calls the function
switch(menu())
{
case 1:
cout<<"\n Enter a number to insert: ";
cin>>no;
myqueue.enqueue(no);
break;
case 2:
no = myqueue.dequeue();
if(INT_MIN != no)
cout<<"\n Deleted number: "<<no;
break;
case 3:
myqueue.displayqueue();
break;
case 4:
if(myqueue.isEmpty())
cout<<"\n Empty Circular Queue.";
else
cout<<"\n Not Empty Circular Queue.";
break;
case 5:
if(myqueue.isFull())
cout<<"\n Full Circular Queue.";
else
cout<<"\n Not Full Circular Queue.";
break;
case 6:
cout<<"\n Front Element of Circular Queue: "<<myqueue.getFront();
break;
case 7:
cout<<"\n Back Element of Circular Queue: "<<myqueue.getBack();
break;
case 8:
cout<<"\n Capacity of Circular Queue: "<<myqueue.getCapacity();
break;
case 9:
cout<<"\n Number of Elements in Circular Queue: "<<myqueue.getSize();
break;
case 10:
exit(0);
default:
cout<<"\n Invalid Choice! Try again.";
}// End of switch - case
}while(1); // End of do - while loop
return 0;
}// End of main function

Sample Output:

Enter the size of the Circular Queue: 10

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 1

Enter a number to insert: 10

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 1

Enter a number to insert: 20

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 1

Enter a number to insert: 30

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 3

Elements in Circular Queue: 10 -> 20 -> 30 ->

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 2

Deleted number: 10

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 4

Not Empty Circular Queue.

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 5

Not Full Circular Queue.

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 6

Front Element of Circular Queue: 20

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 3

Elements in Circular Queue: 20 -> 30 ->

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 7

Back Element of Circular Queue: 30

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 8

Capacity of Circular Queue: 10

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 9

Number of Elements in Circular Queue: 2

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 11

Invalid Choice! Try again.

************************ Circular Queue Menu ************************
1 - Insert.
2 - Delete.
3 - Display.
4 - Check Empty.
5 - Check Full.
6 - Get Front Element.
7 - Get Back Element.
8 - Get Capacity
9 - Get Size
10 - Exit.
What is your choice? 10