Scribd
Upload
62 views6 pages

17 2

The document defines a linked stack data structure and tests its functionality. It creates two linked stacks, myStack and myStack2, pushes elements onto them, and checks that their tops match when myStack2 is created as a copy of myStack. It then pushes a new element onto only myStack2, and verifies their tops no longer match and the equality check returns false.

Uploaded by

studocujunkmail
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
62 views6 pages

17 2

The document defines a linked stack data structure and tests its functionality. It creates two linked stacks, myStack and myStack2, pushes elements onto them, and checks that their tops match when myStack2 is created as a copy of myStack. It then pushes a new element onto only myStack2, and verifies their tops no longer match and the equality check returns false.

Uploaded by

studocujunkmail
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 6

main.

cpp

#include <iostream>
#include "linkedStack.h"

using namespace std;

int main()
{
// create an empty stack to store characters
linkedStackType<char> myStack;

// push characters into myStack


myStack.push('A');
myStack.push('z');
myStack.push('q');

// display the top element of myStack


cout<<"MyStack: " << myStack.top()<<endl;
myStack.pop(); // remove top element of myStack

// display the top element of myStack


cout<<"MyStack: " << myStack.top()<<endl;

// create myStack2 same as myStack using copy constructor


linkedStackType<char> myStack2(myStack);

// display the top element of myStack and myStack2


cout<<"MyStack top: "<<myStack.top()<<endl;
cout<<"MyStack2 top: "<<myStack2.top()<<endl;

// check for equality


cout<<boolalpha<<(myStack2 == myStack)<<endl; // should be true

// push S to myStack2
myStack2.push('S');

// display the top element of myStack and myStack2


cout<<"MyStack top: "<<myStack.top()<<endl;
cout<<"MyStack2 top: "<<myStack2.top()<<endl;
// check for equality
cout<<boolalpha<<(myStack2 == myStack)<<endl; // should be false

return 0;
}
-----------------------------------------------------------------------------------
----------------------
linkedStack.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.
bool operator==(const linkedStackType<Type>& otherStack) const;
// operator ==
// Function that returns true if they have the same number of elements
// and their elements at the corresponding positions are the same.

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=

// overloaded equality operator that returns true if the 2 stacks have the same
number of elements
// and elements in corresponding positions are equal, else return false
template <class Type>
bool linkedStackType<Type>::operator==(const linkedStackType<Type>& otherStack)
const{

// set curr to top of this stack and otherCurr to top of other stack
nodeType<Type>* curr = stackTop;
nodeType<Type>* otherCurr = otherStack.stackTop;

// loop over the 2 stacks


while(curr != nullptr && otherCurr != nullptr)
{
// curr's info and otherCurr's info are not equal, return false since
corresponding elements are not equal
if(curr->info != otherCurr->info)
return false;

// move curr and otherCurr pointer to next node


curr = curr->link;
otherCurr = otherCurr->link;
}

// after the loop if curr or otherCurr have not reached the end, then number of
elements in both stack are not equal, hence return false
if(curr != nullptr || otherCurr != nullptr)
return false;

return true; // number of elements and corresponding elements in both stacks


are equal
} // end of operator==

#endif

// end of linkedStack.h

You might also like