Program 1

Write a program named CHECKZIPS that is used by a package delivery service to check delivery areas. The program contains an array that holds 10 zip codes of areas to which the company makes deliveries. Prompt a user to enter a zip code and display a message indicating whether the zip is in the company’s delivery area.

Program 2

Write a program for The Carefree Resort named ResortPrices that prompts the user to enter the number of days for a resort stay. Then display the price per night and the total price. Nightly rates are $200 for one or two nights, $180 for three or four nights, $160 for five, six, or seven nights and $145 for eight nights or more. 

You should submit the following:

1. Your entire Visual Code (or your preferred IDE’s) project folder (zipped).
2. A word document with your code pasted in it (if there are more than 1 file in your folder with your code, make sure you name the files accordingly.
3. Screenshots of your GUI at run time (after you hit “run” at your IDE). VERY IMPORTANT: PLEASE SUBMIT THE SCREENSHOTS AS SEPARATE FILES, NOT INSIDE THE ZIPPED PROJECT FOLDER. 

This one C++

linkedStacked.h

//Header File: linkedStack.h

#ifndef H_StackType
#define H_StackType

#include <iostream>
#include <cassert>

#include “stackADT.h”

using namespace std;

//Definition of the node
template <class Type>
struct nodeType
{
   Type info;
   nodeType<Type> *link;
};

template <class Type>
class linkedStackType: public stackADT<Type>
{
public:
   const linkedStackType<Type>& operator=
                             (const linkedStackType<Type>&);
     //Overload the assignment operator.

   bool isEmptyStack() const;
     //Function to determine whether the stack is empty.
     //Postcondition: Returns true if the stack is empty;
     //               otherwise returns false.

   bool isFullStack() const;
     //Function to determine whether the stack is full.
     //Postcondition: Returns false.

   void initializeStack();
     //Function to initialize the stack to an empty state.
     //Postcondition: The stack elements are removed;
     //               stackTop = nullptr;

   void push(const Type& newItem);
     //Function to add newItem to the stack.
     //Precondition: The stack exists and is not full.
     //Postcondition: The stack is changed and newItem
     //               is added to the top of the stack.

   Type top() const;
     //Function to return the top element of the stack.
     //Precondition: The stack exists and is not empty.
     //Postcondition: If the stack is empty, the program
     //               terminates; otherwise, the top
     //               element of the stack is returned.

   void pop();
     //Function to remove the top element of the stack.
     //Precondition: The stack exists and is not empty.
     //Postcondition: The stack is changed and the top
     //               element is removed from the stack.

   linkedStackType();
     //Default constructor
     //Postcondition: stackTop = nullptr;

   linkedStackType(const linkedStackType<Type>& otherStack);
     //Copy constructor

   ~linkedStackType();
     //Destructor
     //Postcondition: All the elements of the stack are
     //               removed from the stack.

private:
   nodeType<Type> *stackTop; //pointer to the stack

   void copyStack(const linkedStackType<Type>& otherStack);
     //Function to make a copy of otherStack.
     //Postcondition: A copy of otherStack is created and
     //               assigned to this stack.
};

   //Default constructor
template <class Type>
linkedStackType<Type>::linkedStackType()
{
   stackTop = nullptr;
}

template <class Type>
bool linkedStackType<Type>::isEmptyStack() const
{
   return(stackTop == nullptr);
} //end isEmptyStack

template <class Type>
bool linkedStackType<Type>:: isFullStack() const
{
   return false;
} //end isFullStack

template <class Type>
void linkedStackType<Type>::initializeStack()
{
   nodeType<Type> *temp; //pointer to delete the node

   while (stackTop != nullptr)    //while there are elements in
                               //the stack
   {
       temp = stackTop;    //set temp to point to the
                           //current node
       stackTop = stackTop->link;  //advance stackTop to the
                                   //next node
       delete temp;    //deallocate memory occupied by temp
   }
} //end initializeStack

template <class Type>
void linkedStackType<Type>::push(const Type& newElement)
{
   nodeType<Type> *newNode;  //pointer to create the new node

   newNode = new nodeType<Type>; //create the node

   newNode->info = newElement; //store newElement in the node
   newNode->link = stackTop; //insert newNode before stackTop
   stackTop = newNode;       //set stackTop to point to the
                             //top node
} //end push

template <class Type>
Type linkedStackType<Type>::top() const
{
   assert(stackTop != nullptr); //if stack is empty,
                             //terminate the program
   return stackTop->info;    //return the top element
}//end top

template <class Type>
void linkedStackType<Type>::pop()
{
   nodeType<Type> *temp;   //pointer to deallocate memory

   if (stackTop != nullptr)
   {
       temp = stackTop;  //set temp to point to the top node

       stackTop = stackTop->link;  //advance stackTop to the
                                   //next node
       delete temp;    //delete the top node
   }
   else
       cout << “Cannot remove from an empty stack.” << endl;
}//end pop

template <class Type>
void linkedStackType<Type>::copyStack
                    (const linkedStackType<Type>& otherStack)
{
   nodeType<Type> *newNode, *current, *last;

   if (stackTop != nullptr) //if stack is nonempty, make it empty
       initializeStack();

   if (otherStack.stackTop == nullptr)
       stackTop = nullptr;
   else
   {
       current = otherStack.stackTop;  //set current to point
                                  //to the stack to be copied

           //copy the stackTop element of the stack
       stackTop = new nodeType<Type>;  //create the node

       stackTop->info = current->info; //copy the info
       stackTop->link = nullptr;  //set the link field of the
                               //node to nullptr
       last = stackTop;        //set last to point to the node
       current = current->link;    //set current to point to
                                   //the next node

           //copy the remaining stack
       while (current != nullptr)
       {
           newNode = new nodeType<Type>;
           newNode->info = current->info;
           newNode->link = nullptr;
           last->link = newNode;
           last = newNode;
           current = current->link;
       }//end while
   }//end else
} //end copyStack

   //copy constructor
template <class Type>   
linkedStackType<Type>::linkedStackType(
                     const linkedStackType<Type>& otherStack)
{
   stackTop = nullptr;
   copyStack(otherStack);
}//end copy constructor

   //destructor
template <class Type>
linkedStackType<Type>::~linkedStackType()
{
   initializeStack();
}//end destructor

   //overloading the assignment operator
template <class Type>   
const linkedStackType<Type>& linkedStackType<Type>::operator=
     (const linkedStackType<Type>& otherStack)
{
   if (this != &otherStack) //avoid self-copy
       copyStack(otherStack);

   return *this;
}//end operator=

#endif

don

stackADT.h

//Header file: stackADT.h

#ifndef H_StackADT
#define H_StackADT
 
template <class Type>
class stackADT
{
public:
   virtual void initializeStack() = 0;
      //Method to initialize the stack to an empty state.
      //Postcondition: Stack is empty

   virtual bool isEmptyStack() const = 0;
     //Function to determine whether the stack is empty.
     //Postcondition: Returns true if the stack is empty,
     //               otherwise returns false.

   virtual bool isFullStack() const = 0;
     //Function to determine whether the stack is full.
     //Postcondition: Returns true if the stack is full,
     //               otherwise returns false.

   virtual void push(const Type& newItem) = 0;
     //Function to add newItem to the stack.
     //Precondition: The stack exists and is not full.
     //Postcondition: The stack is changed and newItem
     //               is added to the top of the stack.

   virtual Type top() const = 0;
     //Function to return the top element of the stack.
     //Precondition: The stack exists and is not empty.
     //Postcondition: If the stack is empty, the program
     //               terminates; otherwise, the top element
     //               of the stack is returned.

   virtual void pop() = 0;
     //Function to remove the top element of the stack.
     //Precondition: The stack exists and is not empty.
     //Postcondition: The stack is changed and the top
     //               element is removed from the stack.
};
       
#endif

don

Question 4:

The Programming Example, Converting a Number from Decimal to Binary, in Chapter 6, contains a program that uses recursion to convert a decimal number into an equivalent binary number. By using the linked stack and stack ADT class provided (linkedStack.h and stackADT.h), write a program that uses a stack to convert a decimal number into an equivalent binary number. Submit the cpp file, and copy and paste the screenshot of the output here.