1. Chapter 4
The easy stuff

2. Lists, Stacks, and Queues
If you only need to store a few things, the simplest and easiest approach might be to put them in a list
Only if you need to search or some other more intensive operation on the data would a more complex structure be needed

3. Goals for this Chapter Present some basic data structures
Give examples of separating a logical representation in the form of an ADT from a physical implementation in a Data Structure
Illustrate the use of algorithm analysis in the context of simple operations

4. Lists
A list is a finite, ordered sequence of data items know as elements
Each element has a position
This is a sequence as defined in Chapter 2
It’s empty when it contains no elements
The number of current elements is its length
The first element is the head
The last element is the tail

5. Basic Operations
Must be able to insert and delete anywhere along the list
Should be able to gain access to an elements value
Must be able to create and clear the list
Convenient to gain access to the next element from the current one

6. List ADT
In C++ we will use the notion of an abstract class for the List
We will increase the flexibility by making it a template
The abstract class does not specify how the operations are implemented
Given that we want to support the concept of a sequence, the key decision embodied in the ADT is the notion of position

7. The Fence
The list will be partitioned into two sets with a fence between them
We will use a vertical bar to indicate where the fence is when we need notation to show the fence
<4, 5, 6 | 8, 10, 11>
After an insert
<4, 5, 6 | 13, 8, 10, 11>

8. The List Abstract Class
template <class Elem> class List{
public:
virtual void clear() = 0;
virtual bool insert(const Elem&) = 0;
virtual bool append(const Elem&) = 0;
virtual bool remove(Elem&) = 0;
virtual void setStart() = 0;
virtual void setEnd() = 0;
virtual void prev() = 0;
virtual void next() = 0;
virtual int leftLength() = 0;
virtual int rightLength() = 0;
virtual bool setPos(int pos) = 0;
virtual bool getValue(Elem&) const = 0;
virtual void print() const = 0; };

9. Array Based Implementation
Contains 4 private variables
One for maxSize, listSize, fence, and the listArray
Stores the elements in contiguous memory locations
Shifting can occur with insert and deletes
Inserting and deleting in the average case is Θ(n)

10. Linked Implementation
Key design choice is how to implement the fence
Two choices:
The first node on the right side
The last node on the left side
A header node can eliminate some the special cases that arise from choosing the second option.
It does introduce some overhead

11. Comparision Array list size is predetermined
When list is small, large amount of space can be wasted
Linked list waste space with overhead
No limit to the number of elements in list

12. Breakeven Comparison n number of elements in list
P size of pointer storage
E size of data element
D maximum number of elements stored in array
Space required for Array DE
Space required for Linked n(P+E)
n> DE/(P+E)
When P = E we get D/2 as break even point

13. Dictionary ADT
The most common objective of a computer program is to store and retrieve data
The dictionary is defined to provide the fundamental operations of storing records, finding records and removing records from a database.
We must define concepts of a key and comparable objects

14. The Dictionary ADT
template <class Key, class Elem, class KEComp, class EEComp>
class Dictionary {
public:
virtual void clear() = 0;
virtual bool insert(const Elem&) = 0;
virtual bool remove(const Key&, Elem&) = 0;
virtual bool removeAny(Elem&) = 0;
virtual bool find(const Key&, Elem& ) = 0;
virtual int size() = 0; };

15. What are all those classes for?
We know we need to be able to find records in the dictionary.
We could simply use the basic relational operators.
This doesn’t work for complex types
We could simply overload the basic relational operators
This is hidden in the code
We could require that the Elem class is inheiret off of a class that implements a comparable method
What about multiple keys?

16. Best Solution
Allowing the user to supply their own definitions for comparing keys to records and records to records
By making the class a template parameter, we now have the requirement in the interface
The design is known as a “Strategy” design pattern, since the strategy is provided explicitly by the client

17. Stacks
The stack is a list-like structure in which elements may be inserted or removed from only one end.
A stack follows a LIFO access pattern
Elements are stored and removed in reverse order of their arrival
Elements are pushed on the stack
Elements are popped off the stack

18. Queues
The queue is a list-like structure that provides restricted access to its elements
Elements are enqueued at the back
Elements are dequed from the front
Queues follow a FIFO access pattern