Question

Using C++ in Visual Studios

Rewrite the code to use a Stack instead of a Queue. You will need to think about the differences in the Stack and Queue. Think about how they operate and how the nodes may differ.   Modify the code as necessary.

You will need to push to the Stack, pop from the Stack, peek at the Stack. You will need a member functions like in the example code. Your program will need to show that everything works as it is supposed to, just as the demonstration code does with the queue.

Example Code:

11 Includes we need for file and console input and output. #include <iostream> #include <fstream> // Include ctime for simple random number seeding. Other methods of random number generation // can be used if desired. // #include <ctime> // Using Statement using namespace std; // Node that will be used to create the queue. struct node { // Location to store the data. int number; // Location of the adjacent node. With a queue, we look at the front node. All other // nodes are behind it. node *behind; }; // Class that we will use to protect the data by controlling the operations that are allowed 11 to be performed on the data. class queue { il Class members that are private to the queue. private: // We need to create a node pointer to keep track of the front of the list. // back, we need a pointer for the last node in the list. To insert at node *front; node *back;

Answer 1

/*

A similar program for stack simulating the above implementation details and functional structure and working can be demonstrated by the following code as given below:

*/

#include <iostream>
#include <fstream>
#include <ctime>
#include <limits>

using namespace std;

// Data structure for stack
typedef struct Stack
{
   int maxsize;   // define max capacity of stack
   int top;      
   int *items;
}Stack;

// Utility function to initialize stack
Stack* newStack(int capacity)
{
   Stack *pt = (Stack*)malloc(sizeof(Stack));

   pt->maxsize = capacity;
   pt->top = -1;
   pt->items = (int*)malloc(sizeof(int) * capacity);

   return pt;
}

// Utility function to return the size of the stack
int size(Stack *pt)
{
   return pt->top + 1;
}

// Utility function to check if the stack is empty or not
int isEmpty(Stack *pt)
{
   return pt->top == -1;   // or return size(pt) == 0;
}

// Utility function to check if the stack is full or not
int isFull(Stack *pt)
{
   return pt->top == pt->maxsize - 1;   // or return size(pt) == pt->maxsize;
}

// Utility function to add an element x in the stack
void push(Stack *pt, int x)
{
   // check if stack is already full. Then inserting an element would
   // lead to stack overflow
   if (isFull(pt))
   {
       printf("OverFlow\nProgram Terminated\n");
       exit(EXIT_FAILURE);
   }

  
   // add an element and increments the top index
   pt->items[++pt->top] = x;
}

// Utility function to return top element in a stack
int peek(Stack *pt)
{
   // check for empty stack
   if (!isEmpty(pt))
       return pt->items[pt->top];
   else
       exit(EXIT_FAILURE);
}

// Utility function to pop top element from the stack
int pop(Stack *pt)
{
   // check for stack underflow
   if (isEmpty(pt))
   {
       printf("UnderFlow\nProgram Terminated\n");
       exit(EXIT_FAILURE);
   }

   // decrement stack size by 1 and (optionally) return the popped element
   return pt->items[pt->top--];
}

void viewStack(Stack *s1)
{
   // check for stack underflow
   if (isEmpty(s1))
   {
       printf("No Elements in the stack to view\nProgram Terminated\n");
       exit(EXIT_FAILURE);
   }

   Stack *p1 = newStack(size(s1));
// Print list
printf("Elements in the stack (from top to bottom) are : ");
while(!isEmpty(s1)){
int item = pop(s1);
printf("%d ",item);
push(p1, item);
}
  
while(!isEmpty(p1)){
int item = pop(p1);
push(s1, item);
}
cout<<endl;
}

int GetSize(int);
int CreateDataFile(int);
int DoWork(int);

int main(int argc, char* argv[])
{
if (argc == 2)
{
int size = atoi(argv[1]);

if (!size)
{
cout << "this is not a valid quantity" << endl;

size = GetSize(size);
}

DoWork(size);
}
else
{
int size = 0;

size = GetSize(size);

DoWork(size);
}

return (0);
}

int GetSize(int Size)
{
while (Size < 1 || Size > 100)
{
cout << endl;
cout << "how much data do you want to generate (1 to 100)? ";
cin >> Size;

if (cin.fail() || Size < 1 || Size > 100)
{
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');

cout << endl << "invalid option";
}

cout << endl << endl;
}

return(Size);
}

int CreateDataFile(int Size)
{
ofstream WriteBinary;
WriteBinary.open("numbers.bin", ios::binary);

if (!WriteBinary)
{
cout << "could not open binary file for writing" << endl << endl;
return (1);
}

cout << "writing file: numbers.bin" << endl << endl;

srand(time(NULL));
  
int Data = 0;

int counter = 1;

for (int i = 0; i < Size; i++)
{
Data = rand() % 100;

WriteBinary.write(reinterpret_cast<const char*>(&Data), sizeof(int));

cout << Data << "\t";
if (counter % 10 == 0)
{
cout << endl;
counter = 0;
}
counter = counter + 1;
}

WriteBinary.close();

cout << endl << endl << "the data file was created successfully" << endl;
}

int DoWork(int size)
{
CreateDataFile(size);

Stack *myStack = newStack(size);

ifstream ReadBinary;
ReadBinary.open("numbers.bin", ios::binary);

if (!ReadBinary)
{
cout << "could not open binary file for reading" << endl << endl;
exit(1);
}

int Data = 0;

while (ReadBinary)
{
ReadBinary.read((char*)&Data, sizeof(int));

if (ReadBinary.eof()) break;

push(myStack,Data);
}

viewStack(myStack);

cout<<"Value on peeking (Top of stack) the stack is : (Through method 1) ";

if (!isEmpty(myStack))
{
cout << peek(myStack) << endl;
}
  
cout<<"Value on peeking (Top of stack) the stack is : (Through method 2) ";

if (!isEmpty(myStack))
{
int data = peek(myStack);
cout << data << endl;
}
}

// OUTPUT OF A SAMPLE RUN:

how much data do you want to generate (1 to 100)? 9 writing file: numbers.bin 16 77 5 93 75 72 31 93 66 the data file was created successfully Elements in the stack (from top to bottom) are : 66 93 31 72 75 93 5 77 16 Value on peeking (Top of stack) the stack is : (Through method 1) 66 Value on peeking (Top of stack) the stack is : (Through method 2) 66

// ON ALREADY PROVIDING A COMMAND LINE ARGUMENT:

writing file: numbers.bin 10 76 36 50 47 21 62 the data file was created successfully Elements in the stack (from top to bottom) are : 62 21 47 50 36 76 10 Value on peeking (Top of stack) the stack is : (Through method 1) 62 Value on peeking (Top of stack) the stack is : (Through method 2) 62

// PLEASE DO LIKE AND UPVOTE IF THIS WAS HELPFUL!

// THANK YOU SO MUCH IN ADVANCE!