1 linked stack chapter 4. 2 linked stack we can implement a stack as a linked list. same operations....
TRANSCRIPT
1
Linked Stack
Chapter 4
2
Linked Stack
We can implement a stack as a linked list.
Same operations. No fixed maximum size. Stack can grow indefinitely
Subject only to the amount of memory available.
3
Linked Stack
Rather than implementing a linked stack from scratch we will use an existing Link class and create an adapter.
A wrapper that provides a different interface for an existing class.
Using a linked list to implement a stack is especially simple. The operations provided by the Stack ADT are
a subset of those provided by the List ADT.
4
Getting Started
Create a new empty project Linked_Stack
Copy stack.h and stack_test.cpp from last class into the new Linked_Stack project
http://www.cse.usf.edu/~turnerr/Data_Structures/Downloads/2011_02_07_Stacks/
Add to project. Project > Add Existing Item
5
Getting Started
Download final List Template project: http://www.cse.usf.edu/~turnerr/Data_Structures/
Downloads/2011_02_02_List_of_Objects/Completed_and_Corrected_Version/
Extract files. Copy DLList.h into new project. Add file to project.
Note memory leak in destructor.
Modify stack.h as shown on following slides.We will use a List to hold the stack data.
Stack.h#pragma once
#include <iostream>
#include <cassert>
#include "DLList.h"
template <class T>
class Stack
{
public:
Stack(int capacity = 1000);
~Stack();
bool IsEmpty() const {return data->isEmpty();};
bool IsFull() const {return false;};
// Add a value to the top of the stack.
void Push(const T& value);
// Remove and return value at top of stack.
T Pop();
// Retrieve value at top of stack without removing it.
T Top() const;
// Display stack contents.
void Display(std::ostream& out) const;
7
Stack.h
private:
DLList<T>* data;
//int size;
//int top; // Index of element at top of stack
// // -1 when stack is empty
};
8
Constructor and Destructor
template <class T>
Stack<T>::Stack(int capacity) Delete initialization list{
data = new DLList<T>();
assert (data != 0);
}
template <class T>
Stack<T>::~Stack()
{
delete data; Remove [] }
9
Push()
template <class T>
void Stack<T>::Push(const T& value)
{
data->addToHead(value);
}
10
Pop()
template <class T>
T Stack<T>::Pop()
{
if (this->IsEmpty())
{
throw "Pop called for empty stack";
}
return data->deleteFromHead();
}
11
Top()
template <class T>
T Stack<T>::Top() const
{
if (this->IsEmpty())
{
throw "Top of empty stack requested";
}
T temp = data->deleteFromHead();
data->addToHead(temp);
return temp;
}
12
Display()
template <class T>
void Stack<T>::Display(std::ostream& out) const
{
data->printAll();
}
13
stack_test
Our test should work unchanged Except: We can't force overflow
now. Comment out the section that tests
stack overflow. Lines 28 – 41 of stack_test.cpp
Build
14
A Warning
The isEmpty method in the List template should have been declared as bool.
Make that change.
15
Program Running
16
Try it on Linux
17
Try it on Linux
The Visual Studio compiler is more forgiving!
Add using namespace std; to printAll.
18
OK This Time
19
An Application
Adding arbitrarily large numbers.
Unlike pencil and paper arithmetic, computer arithmetic typically has a maximum size for numbers.
We can use stacks to implement addition for arbitrarily large numbers. Drozdek, page 141
20
Modify printAll()
Modify DLList::printAll() to output all items on the same line.
cout << p->info << " ";
21
Adding Arbitrarily Large Integers
int main()
{
Stack<int> lhs;
Stack<int> rhs;
Stack<int> result;
get_integer(lhs);
get_integer(rhs);
cout << "\nLHS = ";
lhs.Display(cout);
cout << "\nRHS = ";
rhs.Display(cout);
cin.get();
cin.get();
}
22
get_integer()
void get_integer(Stack<int>& stack)
{
cout << "Enter an integer: ";
char c = cin.get();
while (c != '\n')
{
assert (isdigit(c));
stack.Push(c - '0');
c = cin.get();
}
}
23
Program in Action
24
Program in Action
25
Add to main()
add(lhs, rhs, result);
cout << "\nSum = ";
result.Display(cout);
cout << endl;
26
Function Add()
void add(Stack<int>& lhs,
Stack<int>& rhs,
Stack<int>& result)
{
int carry = 0;
while (!lhs.IsEmpty() || !rhs.IsEmpty() || carry > 0)
{
int next_lhs_digit = 0;
int next_rhs_digit = 0;
if (!lhs.IsEmpty())
{
next_lhs_digit = lhs.Pop();
}
if (!rhs.IsEmpty())
{
next_rhs_digit = rhs.Pop();
}
27
Function Add()
int next_sum_digit =
next_lhs_digit + next_rhs_digit + carry;
if (next_sum_digit > 9)
{
carry = 1;
next_sum_digit -= 10;
}
else
{
carry = 0;
}
result.Push(next_sum_digit);
}
}
28
A Small Example
29
A Big Example
30
Another Big Example