1. Stacks and Linked Lists

2. Abstract Data Types (ADTs)
An ADT is an abstraction of a data structure that specifies
Data stored
Operations on the data
Error conditions associated with operations

3. Abstract Data Types (ADTs)
An ADT is an abstraction of a data structure that specifies
Data stored
Operations on the data
Error conditions associated with operations
Example: Registering for classes
The data stored are the courses in your schedule
The operations supported are
Register(course)
Unregister(course)
ForceRequest(course)
Error conditions:
Registering for multiple classes meeting at the same time

4. Stacks

5. Stacks
Stacks store arbitrary objects (Pez in this case)

6. Stacks Stacks store arbitrary objects (Pez in this case) Operations
push(e): inserts an element to the top of the stack

7. Stacks Stacks store arbitrary objects (Pez in this case) Operations
push(e): inserts an element to the top of the stack

8. Stacks Stacks store arbitrary objects (Pez in this case) Operations
push(e): inserts an element to the top of the stack
pop(): removes and returns the top element of the stack

9. Stacks Stacks store arbitrary objects (Pez in this case) Operations
push(e): inserts an element to the top of the stack
pop(): removes and returns the top element of the stack

10. Stacks Stacks store arbitrary objects (Pez in this case) Operations
push(e): inserts an element to the top of the stack
pop(): removes and returns the top element of the stack

11. Stacks Stacks store arbitrary objects (Pez in this case) Operations
push(e): inserts an element to the top of the stack
pop(): removes and returns the top element of the stack
top(): returns a reference to the top element of the stack, but doesn’t remove it

12. Stacks Stacks store arbitrary objects (Pez in this case) Operations
push(e): inserts an element to the top of the stack
pop(): removes and returns the top element of the stack
top(): returns a reference to the top element of the stack, but doesn’t remove it
Optional operations
size(): returns the number of elements in the stack
empty(): returns a bool indicating if the stack contains any objects

13. Stack Exceptions
Attempting to execute an operation of ADT may cause an error condition called an exception
Exceptions are said to be “thrown” by an operation that cannot be executed
In the Stack ADT, pop and top cannot be performed if the stack is empty
Attempting to execute pop or top on an empty stack throws an EmptyStackException

14. Exercise: Stacks
Describe the output and final structure of the stack after the following operations:
Push(8)
Push(3)
Pop()
Push(2)
Push(5)
Push(9)
Push(1)

15. Applications of Stacks
Direct applications
Page-visited history in a Web browser
Undo sequence in a text editor
Saving local variables when one function calls another, and this one calls another, and so on.
Indirect applications
Auxiliary data structure for algorithms
Component of other data structures

16. C++ Run-time Stack
main() { int i;
i = 5; foo(i); }
foo(int j) { int k; k = j+1; bar(k); }
bar(int m) { … }
The C++ run-time system keeps track of the chain of active functions with a stack
When a function is called, the run-time system pushes on the stack a frame containing
Local variables and return value
Program counter, keeping track of the statement being executed
When a function returns, its frame is popped from the stack and control is passed to the method on top of the stack
bar
PC = 1 m = 6
foo
PC = 3 j = 5
k = 6
main
PC = 2 i = 5

17. Array-based Stack
Algorithm size()
return t + 1
Algorithm empty()
return size () == 0
Algorithm pop()
if empty() then
throw EmptyStackException
else
t  t  1
return S[t + 1]
A simple way of implementing the Stack ADT uses an array
We add elements from left to right
A variable keeps track of the index of the top element … S 1 2 t

18. Array-based Stack (cont.)
The array storing the stack elements may become full
A push operation will then throw a FullStackException
Limitation of the array-based implementation
Not intrinsic to the Stack ADT
Algorithm push(e)
if t = S.length  1 then
throw FullStackException
else
t  t + 1
S[t]  e S 1 2 t …

19. Performance and Limitations (array-based implementation of stack ADT)
Let n be the number of elements in the stack
The space used is O(n)
Each operation runs in time O(1)
Limitations
The maximum size of the stack must be defined a priori , and cannot be changed
Trying to push a new element into a full stack causes an implementation-specific exception

20. Growable Array-based Stack
In a push operation, when the array is full, instead of throwing an exception, we can replace the array with a larger one
How large should the new array be?
incremental strategy: increase the size by a constant c
doubling strategy: double the size
Algorithm push(o)
if t = S.length  1 then
A  new array of
size …
for i  0 to t do
A[i]  S[i]
S  A
t  t + 1
S[t]  o

21. Comparison
We compare the incremental strategy and the doubling strategy by analyzing the total time T(n) needed to perform a series of n push operations
Assume that we start with an empty stack represented by an array of size 1
We call amortized time of a push operation the average time taken by a push over the series of operations, i.e., T(n)/n

22. Incremental Strategy Analysis
We replace the array k = n/c times
The total time T(n) of a series of n push operations is proportional to
n + c + 2c + 3c + 4c + … + kc =
n + c( … + k) =
n + ck(k + 1)/2
Since c is a constant, T(n) is O(n + k2) = O(n2)
The amortized time of a push operation is O(n)

23. Doubling Strategy Analysis
We replace the array k = log2 n times
The total time T(n) of a series of n push operations is proportional to
n …+ 2k =
n + 2k = 3n -1
T(n) is O(n)
The amortized time of a push operation is O(1)

24. Stack Interface in C++
template <class Type> class Stack { public: int size(); bool isEmpty(); Type& top() throw(EmptyStackException); void push(Type e); Type pop() throw(EmptyStackException); };
Requires the definition of class EmptyStackException
Most similar STL construct is vector

25. Array-based Stack in C++
template <class Type>
class ArrayStack {
private:
int capacity; // stack capacity
Type *S; // stack array
int t; // top of stack
public:
ArrayStack(int c) : capacity(c) {
S = new Type [ capacity ];
t = -1; }
bool isEmpty() { return t < 0; }
Type pop() throw(EmptyStackException) {
if ( isEmpty ( ) )
throw EmptyStackException(“Popping from empty stack”);
return S [ t-- ];
//… (other functions omitted)

26. Singly Linked List
A singly linked list is a structure consisting of a sequence of nodes
A singly linked list stores a pointer to the first node (head) and last (tail)
Each node stores
element
link to the next node
next
node
elem
tail
head 
Leonard
Sheldon
Howard
Raj

27. Singly Linked List Node in C++
template <class Type> class SLinkedListNode { public: Type elem;
SLinkedListNode<Type> *next; };
next
node
elem 
Leonard
Sheldon
Howard
Raj

28. Singly Linked List
A singly linked list is a structure consisting of a sequence of nodes
Operations
insertFront(e): inserts an element on the front of the list
removeFront(): returns and removes the element at the front of the list
insertBack(e): inserts an element on the back of the list
removeBack(): returns and removes the element at the end of the list

29. Inserting at the Front Allocate a new node
Have new node point to old head
Update head to point to new node
head
tail 
Leonard
Sheldon
Howard
Raj

30. Inserting at the Front Allocate a new node
Have new node point to old head
Update head to point to new node
head
tail  
Penny
Leonard
Sheldon
Howard
Raj

31. Inserting at the Front Allocate a new node
Have new node point to old head
Update head to point to new node
head
tail 
Penny
Leonard
Sheldon
Howard
Raj

32. Inserting at the Front Allocate a new node
Have new node point to old head
Update head to point to new node
tail
head 
Penny
Leonard
Sheldon
Howard
Raj

33. Inserting at the Front Allocate a new node
Have new node point to old head
Update head to point to new node
head
tail  

34. Inserting at the Front Allocate a new node
Have new node point to old head
Update head to point to new node
head
tail   
Raj

35. Inserting at the Front Allocate a new node
Have new node point to old head
Update head to point to new node
If tail is NULL, update tail to point to the head node
head
tail 
Raj

36. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail 
Leonard
Sheldon
Howard
Raj

37. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail 
Leonard
Sheldon
Howard
Raj

38. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail 
Leonard
Sheldon
Howard
Raj

39. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail 
Leonard
Sheldon
Howard
Raj

40. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail 
Sheldon
Howard
Raj

41. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail 
Sheldon

42. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail  
Sheldon

43. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail  
Sheldon

44. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
head
tail  
Sheldon

45. Removing at the Front Update head to point to next node in the list
Return elem of previous head and delete the node
If head is NULL, update tail to NULL
head
tail  

46. Inserting at the Back Allocate a new node
If tail is NULL, update head and tail to point to the new node; otherwise
Have the old tail point to the new node
Update tail to point to new node
head
tail 
Leonard
Sheldon
Howard

47. Inserting at the Back Allocate a new node
If tail is NULL, update head and tail to point to the new node; otherwise
Have the old tail point to the new node
Update tail to point to new node
head
tail  
Leonard
Sheldon
Howard
Raj

48. Inserting at the Back Allocate a new node
If tail is NULL, update head and tail to point to the new node; otherwise
Have the old tail point to the new node
Update tail to point to new node
head
tail 
Leonard
Sheldon
Howard
Raj

49. Inserting at the Back Allocate a new node
If tail is NULL, update head and tail to point to the new node; otherwise
Have the old tail point to the new node
Update tail to point to new node
head
tail 
Leonard
Sheldon
Howard
Raj

50. Removing at the Back No efficient way of doing so (O(n))
Typically would not use a singly linked-list if this operation is commonly used
head
tail 
Leonard
Sheldon
Howard
Raj

51. Stack with a Singly Linked List
We can implement a stack with a singly linked list
The top element of the stack is the first node of the list
The space used is O(n) and each operation of the Stack ADT takes O(1) time
nodes t
top 
elements

52. Stack Summary Stack Operation Complexity for Different Implementations
Array
Fixed-Size
Expandable (doubling strategy)
Singly
Linked
List
Pop()
O(1)
Push(o)
O(n) Worst Case
O(1) Best Case
O(1) Average Case
Top()
Size(), isEmpty()

53. Queues

54. Queues Auxiliary queue operations: Exceptions
Queues store arbitrary objects
Insertions are at the end of the queue and removals are at the front of the queue
Main queue operations:
enqueue(e): inserts an element at the end of the queue
dequeue(): removes and returns the element at the front of the queue
Auxiliary queue operations:
front(): returns the element at the front without removing it
size(): returns the number of elements stored
isEmpty(): returns a boolean value indicating if there are no elements in the queue
Exceptions
Attempting to execute dequeue or front on an empty queue throws an EmptyQueueException

55. Exercise: Queues
Describe the output and final structure of the queue after the following operations:
enqueue(8)
enqueue(3)
dequeue()
enqueue(2)
enqueue(5)
enqueue(9)
enqueue(1)

56. Applications of Queues
Direct applications
Waiting lines
Access to shared resources (e.g., printer)
User input in a game
Indirect applications
Auxiliary data structure for algorithms
Component of other data structures

57. wrapped-around configuration
Array-based Queue
Use an array of size N in a circular fashion
Two variables keep track of the front and rear
f index of the front element
r index immediately past the rear element
Array location r is kept empty
normal configuration Q 1 2 r f
wrapped-around configuration Q 1 2 f r

58. Queue Operations We use the modulo operator (remainder of division)
Algorithm size()
return (N - f + r) mod N
Algorithm isEmpty()
return (f = r) Q 1 2 r f Q 1 2 f r

59. Queue Operations (cont.)
Algorithm enqueue(o)
if size() = N  1 then
throw FullQueueException
else
Q[r]  o
r  (r + 1) mod N
Operation enqueue throws an exception if the array is full
This exception is implementation-dependent Q 1 2 r f Q 1 2 f r

60. Queue Operations (cont.)
Algorithm dequeue()
if isEmpty() then
throw EmptyQueueException
else
o  Q[f]
f  (f + 1) mod N
return o
Operation dequeue throws an exception if the queue is empty
This exception is specified in the queue ADT Q 1 2 r f Q 1 2 f r

61. Performance and Limitations - array-based implementation of queue ADT
Let n be the number of elements in the queue
The space used is O(n)
Each operation runs in time O(1)
Limitations
The maximum size of the queue must be defined a priori , and cannot be changed
Trying to enqueue a new element into a full queue causes an implementation-specific exception

62. Growable Array-based Queue
In an enqueue operation, when the array is full, instead of throwing an exception, we can replace the array with a larger one
Similar to what we did for an array-based stack
The enqueue operation has amortized running time
O(n) with the incremental strategy
O(1) with the doubling strategy

63. Exercise Describe how to implement a queue using a singly-linked list
Queue operations: enqueue(x), dequeue(), size(), isEmpty()
For each operation, give the running time

64. Queue with a Singly Linked List
We can implement a queue with a singly linked list
The front element is stored at the head of the list
The rear element is stored at the tail of the list
The space used is O(n) and each operation of the Queue ADT takes O(1) time
NOTE: we do not have the limitation of the array based implementation on the size of the stack b/c the size of the linked list is not fixed, I.e., the queue is NEVER full.
head
tail 
Leonard
Sheldon
Howard
Raj

65. Informal C++ Queue Interface
template <class Type> class Queue { public: int size(); bool isEmpty(); Type& front() throw(EmptyQueueException); void enqueue(Type e); Type dequeue() throw(EmptyQueueException); };
Informal C++ interface for our Queue ADT
Requires the definition of class EmptyQueueException
No corresponding built-in STL class

66. Queue Summary Queue Operation Complexity for Different Implementations
Array
Fixed-Size
Expandable (doubling strategy)
List
Singly-Linked
dequeue()
O(1)
enqueue(o)
O(n) Worst Case
O(1) Best Case
O(1) Average Case
front()
Size(), isEmpty()

67. Double-Ended Queues Auxiliary deque operations: Exceptions
The Double-Ended Queue, or Deque, ADT stores arbitrary objects. (Pronounced ‘deck’)
Richer than stack or queue ADTs. Supports insertions and deletions at both the front and the end.
Main deque operations:
insertFirst(object o): inserts element o at the beginning of the deque
insertLast(object o): inserts element o at the end of the deque
removeFirst(): removes and returns the element at the front of the deque
removeLast(): removes and returns the element at the end of the deque
Auxiliary deque operations:
first(): returns the element at the front without removing it
last(): returns the element at the front without removing it
size(): returns the number of elements stored
isEmpty(): returns a Boolean value indicating whether no elements are stored
Exceptions
Attempting to execute removeFirst,removeLast, front, or last on an empty deque throws an EmptyDequeException

68. Doubly Linked List
A doubly linked list is a structure consisting of a sequence of nodes
A doubly linked list stores a pointer to a special head/tail node
Each node stores
element
link to the prev, next node
next
prev
elem
node
head
tail
Leonard
Sheldon
Howard
Raj

69. Doubly Linked List
A doubly linked list is a structure consisting of a sequence of nodes
A doubly linked list stores a pointer to a special head/tail node
Each node stores
element
link to the prev, next node
next
prev
elem
node
head
tail

70. Doubly Linked List Node in C++
template <class Type> class DLinkedListNode { public: Type elem;
DLinkedListNode<Type> *prev, *next; };
next
prev
elem
node
head
tail
Leonard
Sheldon
Howard
Raj

71. Doubly Linked List
A doubly linked list is a structure consisting of a sequence of nodes
Operations
insertFront(e): inserts an element on the front of the list
removeFront(): returns and removes the element at the front of the list
insertBack(e): inserts an element on the back of the list
removeBack(): returns and removes the element at the end of the list
Private operations
add(n, e): inserts the element after the node n
remove(n): returns and removes the element stored in the node n

72. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
head
tail
Leonard
Sheldon
Howard
Raj

73. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
Bernadette
head
tail
Leonard
Sheldon
Howard
Raj

74. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
Bernadette
head
tail
Leonard
Sheldon
Howard
Raj

75. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
Bernadette
head
tail
Leonard
Sheldon
Howard
Raj

76. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
head
tail
Leonard
Sheldon
Howard
Bernadette
Raj

77. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
Sheldon
head
tail

78. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
Sheldon
head
tail

79. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
Sheldon
head
tail

80. Adding a Node Allocate a new node
Have new node point to the previous and next nodes
Update the previous and next nodes to point to the new node
head
tail
Sheldon

81. Removing a Node
Have the prev node’s next point to the next of the current node
Have the next node’s prev point to the prev of the current node
Delete the current node
head
tail
Leonard
Sheldon
Howard
Raj

82. Removing a Node
Have the prev node’s next point to the next of the current node
Have the next node’s prev point to the prev of the current node
Delete the current node
head
tail
Leonard
Sheldon
Howard
Raj

83. Removing a Node
Have the prev node’s next point to the next of the current node
Have the next node’s prev point to the prev of the current node
Delete the current node
head
tail
Leonard
Sheldon
Howard
Raj

84. Removing a Node
Have the prev node’s next point to the next of the current node
Have the next node’s prev point to the prev of the current node
Delete the current node
head
tail
Leonard
Sheldon
Howard
Raj

85. Removing a Node
Have the prev node’s next point to the next of the current node
Have the next node’s prev point to the prev of the current node
Delete the current node
head
tail
Leonard
Sheldon
Raj

86. Deque with a Doubly Linked List
We can implement a deque with a doubly linked list
The front element is pointed to by head
The rear element is pointed to by tail
The space used is O(n) and each operation of the Deque ADT takes O(1) time
head
tail
Leonard
Sheldon
Howard
Raj

87. Performance and Limitations - doubly linked list implementation of deque ADT
Let n be the number of elements in the deque
The space used is O(n)
Each operation runs in time O(1)
Limitations
NOTE: we do not have the limitation of the array based implementation on the size of the deque b/c the size of the linked list is not fixed, I.e., the deque is NEVER full.

88. Deque Summary Deque Operation Complexity for Different Implementations
Array
Fixed-Size
Expandable (doubling strategy)
List
Singly-Linked
Doubly-Linked
removeFirst(), removeLast()
O(1)
O(1) – removeFirst, O(n) – removeLast
insertFirst(o), InsertLast(o)
O(n) Worst Case
O(1) Best Case
O(1) Average Case
first(), last
size(), isEmpty()