Question

Study the "Queue as linked list simple example" posted in this module. Rewrite the code to use array instead of linked lists. Please do not change anything besides the data structure. Instead of linked list use an array. The functionality should remain exactly the same.

LListQueue.cpp

///---------------------------------------------------------------

/// File: LListQueue.cpp

/// Purpose: Implementation file for a demonstration of a queue

/// implemented as an array. Data type: Character

/// Programming Language: C++

///---------------------------------------------------------------

#include "LListQueue.h"

///--------------------------------------------

/// Function: LListQueue()

/// Purpose: Class constructor

/// Returns: void

///--------------------------------------------

LListQueue::LListQueue()

{

head = tail = nullptr;

}

///--------------------------------------------

/// Function: Code137_Queue()

/// Purpose: Class destructor

/// Returns: void

///--------------------------------------------

LListQueue::~LListQueue()

{

ClearQueue();

}

///--------------------------------------------

/// Function: ClearQueue()

/// Purpose: Remove all items from the queue

/// Returns: void

///--------------------------------------------

void LListQueue::ClearQueue()

{

QNode *temp;

while(head != nullptr)

{

temp = head;

head = head->next;

delete temp;

}

head = tail = nullptr; // Reset indices to start over

}

///--------------------------------------------

/// Function: Enqueue()

/// Purpose: Enqueue an item into the queue.

/// Returns: true if enqueue was successful

/// or false if the enqueue failed.

///--------------------------------------------

bool LListQueue::Enqueue(char ch)

{

QNode *temp;

/// Check to see if the Queue is full

if(isFull()) return false;

/// Create new node for the queue

temp = new QNode ();

temp->ch = ch;

temp->next = nullptr;

/// Check for inserting first in the queue

if(head == nullptr)

head = tail = temp;

else

{

tail->next = temp; /// Insert into the queue

tail = temp; /// Set tail to new last node

}

return true;

}

///--------------------------------------------

/// Function: Dequeue()

/// Purpose: Dequeue an item from the Queue.

/// Returns: Character being dequeued or '\0'

/// if dequeue failed.

//--------------------------------------------

char LListQueue::Dequeue()

{

char ch;

QNode *temp;

/// Check for empty Queue

if(isEmpty()) return '\0'; /// Return null character if queue is empty

else

{

ch = head->ch; /// Get character to return

temp = head;

head = head->next; /// Advance head pointer

delete temp; /// Free old head

/// Check to see if queue is empty

if(isEmpty())

{

head = tail = nullptr; /// Reset everything to empty queue

}

}

return ch; /// Return popped character

}

///--------------------------------------------

/// Function: isEmpty()

/// Purpose: Return true if the queue is empty

/// Returns: true if empty, otherwise false

///--------------------------------------------

bool LListQueue::isEmpty()

{

return (head == nullptr);

}

///--------------------------------------------

/// Function: isFull()

/// Purpose: Return true if the queue is full

/// Returns: true if full, otherwise false

///--------------------------------------------

bool LListQueue::isFull()

{

return false;

}

LListQueue.h

#ifndef LLISTQUEUE_H_INCLUDED

#define LLISTQUEUE_H_INCLUDED

///---------------------------------------------------------------

/// File: LListQueue.h

/// Purpose: Header file for a demonstration of a queue implemented

/// as a linked structure. Data type: Character

/// Programming Language: C++

///---------------------------------------------------------------

struct QNode

{

char ch;

QNode *next;

};

class LListQueue

{

private:

QNode *head, *tail; /// Pointers to head and tail of the queue

public:

LListQueue(); /// Class constructor

~LListQueue(); /// Class destuctor

void ClearQueue(); /// Remove all items from the queue

bool Enqueue(char ch); /// Enter an item in the queue

char Dequeue(); /// Remove an item from the queue

bool isEmpty(); /// Return true if queue is empty

bool isFull(); /// Return true if queue is full

};

#endif /// LLISTQUEUE_H_INCLUDED

main.cpp

///---------------------------------------------------------------

/// File: QueueMain.c

/// Purpose: Main file with tests for a demonstration of a queue

/// as a linked structure.

/// Programming Language: C++

///---------------------------------------------------------------

#include "LListQueue.h"

#include <iostream>

#include <cstring>

using namespace std;

int main()

{

char testString[27];

int i;

char ch;

LListQueue *Q;

cout << "Simple Queue Demonstration\n";

cout << "(Queue implemented as an Array - Queue data type is character.)\n\n";

cout << "Creating a queue\n";

Q = new LListQueue();

cout << "Queue created...\n";

/// Test enqueuing and dequing item on a queue

cout << "Testing enqueue and dequeue of single item.\n";

Q->Enqueue('A');

cout << "Enqueued: " << Q->Dequeue() << "\n";

cout << "...done\n\n";

/// Test queue by enqueing letters in a string

strcpy(testString, "abcdefghijklmnopqrasuvwxyz");

/// Try to Enqueue all letters in the string

i = 0;

cout << "Testing enqueuing of string: " << testString << "\n";

while(testString[i] != '\0')

{

if(!Q->Enqueue(testString[i]))

{

cout << "Queue is full. Unable to enqueue " << testString[i] << "\n";

}

i++;

}

cout << "\n\nDone testing enqueue.\n\nNow testing dequeue.\n";

/// Dequeue letters and print them

cout << "Dequeued letters are...\n";

while((ch = Q->Dequeue()) != '\0') /// Dequeue returns null terminator

cout << ch; /// when queue is empty

cout << "\nEnd of queue encountered...\n";

cout << "\n\n...done.\n";

return 0;

}

Answer 1

Below is the C++ code for the above problem with the proper description provided within comments itself. Below code, some sample output screenshots are attached.

If you need any other help for this Comment me below. Thanks

C++ code :

/**
* Queue implementation using linked list C style implementation ( no OOP).
*/

#include<cstdio>
#include<cstdlib>
#include<climits>
#include<iostream>

#define CAPACITY 100 // Queue max capacity

using namespace std;
/** Queue structure definition */
int queuearray[CAPACITY];
int rearptr, frontptr;
/** Queue size */
unsigned int size = 0;

int enqueue(int data);
int dequeue();
int getRear();
int getFront();
void display();
int isEmpty();
int isFull();
string prepMenu();

int main() {
int option, data;

int rear, front;

rearptr = -1;
frontptr = -1;
string menu = prepMenu();
cout << menu << endl;
cin >> option;
while (option != 7) {

switch (option) {
case 1:
cout << "\nEnter data to enqueue (-99 to stop): ";
cin >> data;
while (data != -99) {
/// Enqueue function returns 1 on success
/// otherwise 0
if (enqueue(data))
cout << "Element added to queue.";
else
cout << "Queue is full." << endl;
cout << "\nEnter data to enqueue (-99 to stop): ";
cin >> data;
}

break;

case 2:
data = dequeue();

/// on success dequeue returns element removed
/// otherwise returns INT_MIN
if (data == INT_MIN)
cout << "Queue is empty." << endl;
else
cout << "Data => " << data << endl;

break;

case 3:

/// isEmpty() function returns 1 if queue is emtpy
/// otherwise returns 0
if (isEmpty())
cout << "Queue is empty." << endl;
else
cout << "Queue size => " << size << endl;

break;

case 4:
data = getRear();

if (data == INT_MIN)
cout << "Queue is empty." << endl;
else
cout << "Rear => " << data << endl;

break;

case 5:

data = getFront();

if (data == INT_MIN)
cout << "Queue is empty." << endl;
else
cout << "Front => " << data << endl;

break;

case 6:
display();
break;

default:
cout << "Invalid choice, please input number between (0-5).\n";
break;
}

cout << "\n\n";
cout << menu << endl;
cin >> option;
}
}

/**
* Enqueues/Insert an element at the rear of a queue.
* Function returns 1 on success otherwise returns 0.
*/
int enqueue(int data) {
if(rearptr > CAPACITY) {
frontptr=rearptr=-1;
return 0;
}
queuearray[++rearptr]=data;
size++;
cout<<rearptr;
return 1;
}

/**
* Dequeues/Removes an element from front of the queue.
* It returns the element on success otherwise returns
* INT_MIN as error code.
*/
int dequeue() {
if(frontptr==rearptr) {
return INT_MIN;
}
int data = queuearray[++frontptr];
size--;
return data;
}

/**
* Gets, element at rear of the queue. It returns the element
* at rear of the queue on success otherwise return INT_MIN as
* error code.
*/
int getRear() {
// Return INT_MIN if queue is empty otherwise rear.
return (isEmpty()) ?
INT_MIN :
queuearray[rearptr];
}

/**
* Gets, element at front of the queue. It returns the element
* at front of the queue on success otherwise return INT_MIN as
* error code.
*/
int getFront() {
// Return INT_MIN if queue is empty otherwise front.
return (isEmpty()) ?
INT_MIN :
queuearray[frontptr+1];
}

/**
* Checks, if queue is empty or not.
*/
int isEmpty() {
return (frontptr==rearptr);
}

/**
* Checks, if queue is within the maximum queue capacity.
*/
int isFull() {
return (rearptr > CAPACITY);
}
string prepMenu() {

string menu = "";

menu += " \n-------------------------------------------------------------------\n";
menu += "1.Enqueue 2.Dequeue 3.Size 4.Get Rear 5.Get Front 6.Display 7.Exit\n";
menu += "----------------------------------------------------------------------\n";
menu += "Select an option: ";
return menu;
}
void display() {
for (int t = frontptr+1; t != rearptr+1; t++)
cout << queuearray[t] << " ";
cout << endl << endl;
}
Output :