Lists, Stacks, and Queues

Lists, Stacks, and Queues
(Lists, Stacks, and Queues ) Data Structures and Programming Spring 2017 1 / 50
Abstract Data Types (ADT)
Data type
I a set of objects + a set of operations
I Example: integer
F set of integer numbers
F operations: +, -, x, /
Can this be generalized? e.g. procedures generalize the notion of
an operator
Abstract data type
I what can be stored in the ADT
I what operations can be done on/by the ADT
Encapsulation
I Operations on ADT can only be done by calling appropriate
functions
I no mention of how the set of operations is implemented
I ADT → C++: class
I method → C++: member function
Abstract Data Types (Cont’d)
Object-Oriented Design
A technique for developing a program in which the solution is

expressed in terms of objects – self- contained entities composed of
data and operations on that data.
More about OOD
Languages supporting OOD include: C++, Java, Smalltalk, Eiffel,

and Object-Pascal.
A class is a programmer-defined data type and objects are
variables of that type.
In C++, cin is an object of a data type (class) named istream, and
cout is an object of a class ostream. Header files iostream.h and
fstream.h contain definitions of stream classes.
Client Code Using DateType
2 Separate Files Generally Used for Class Type
DateType Class Instance Diagrams
Implementation of DateType member functions
Implementation of DateType member functions
(Cont’d)
The List ADT
A sequence of zero or more elements:
A1 , A2 , A3 , · · · , AN
N: length of the list
A1 : first element
AN : last element
If N = 0, then empty list
I Ai precedes Ai+1
I Ai follows Ai−1
List Operations
printList: print the list

makeEmpty: create an empty list
find: locate the position of an object in a list
I list: 34,12, 52, 16, 12
I find(52) → 3
insert: insert an object to a list
I insert(x,3) → 34, 12, 52, x, 16, 12
remove: delete an element from the list
I remove(52) → 34, 12, x, 16, 12
findKth: retrieve the element at a certain position
Implementation of an ADT
Choose a data structure to represent the ADT. E.g. arrays, records,

etc.
Each operation associated with the ADT is implemented by one or
more subroutines
Two standard implementations for the list ADT
I Array-based
I Linked list
Array Implementation
Requires an estimate of the maximum size of the list – waste space

printList and find: linear
findKth: constant
insert and delete: slow
I e.g. insert at position 0 (making a new element) requires first
pushing the entire array down one spot to make room
I e.g. delete at position 0 requires shifting all the elements in the list
up one
I On average, half of the lists needs to be moved for either operation
Pointer Implementation (Linked List)
The list is not stored contiguously

A series of structures that are not necessarily adjacent
Each node contains the element and a pointer to a structure
containing its successor; the last cells next link points to NULL
Compared to the array implementation,
√
I the pointer implementation uses only as much space as is needed
for the elements currently on the list
I × but requires space for the pointers in each cell
Linked Lists
A linked list is a series of connected nodes

Each node contains at least
I A piece of data (any type)
I Pointer to the next node in the list
Head: pointer to the first node
The last node points to NULL
A Simple Linked List Class
Declare Node class for the nodes
Declare List, which contains

I head: a pointer to the first node in the list.
I Since the list is empty initially, head is set to NULL Operations on
List
Inserting a New Node
Node* InsertNode(int index, double x)
I Insert a node with data equal to x after the index’th elements.
(i.e., when index = 0, insert the node as the first element; when
index = 1, insert the node after the first element, and so on)
I If the insertion is successful, return the inserted node. Otherwise,
return NULL.
(If index is < 0 or > length of the list, the insertion will fail.)
Steps
I Locate index’th element
I Allocate memory for the new node
I Point the new node to its successor
I Point the new nodes predecessor to the new node
Inserting a New Node (Cont’d)
Deleting a Node
Deleting a Node (Cont’d)
Destroying the list
∼List(void)
I Use the destructor to release all the memory used by the list.
I Step through the list and delete each node one by one.
Variations of Linked Lists
Circular linked lists
I The last node points to the first node of the list
I How do we know when we have finished traversing the list? (Tip:
check if the pointer of the current node is equal to the head.)
Doubly linked lists

I Each node points to not only successor but the predecessor
I There are two NULL: at the first and last nodes in the list
I Advantage: given a node, it is easy to visit its predecessor.
Convenient to traverse lists backwards
Doubly-Linked List
insert(X, A): insert node A before X
remove(X)
Problems with operations at ends of list
Sentinel Nodes
Dummy head and tail nodes to avoid special cases at ends of list
Doubly-linked list with sentinel nodes
Empty doubly-linked list with sentinel nodes
Link Inversion
Forward:
··· A → B → C → D ···
⇑ ↑
prev pres
··· ← A B → C → D ···
⇑ ↑
··· ← A ← B C → D ···
⇑ ↑
Backward ...
Exclusive-Or Doubly Linked List
An XOR linked list compresses the same information into one L

address field by storing the bitwise XOR (here denoted by ) of
the address for previous and the address for next in one field
Addr · · · A B
L C
L D
L E ···
Link ↔ A C↔ B D ↔ C E
More formally: L L
link(B) = addr(A) addr(C), link(C) = addr(B) addr(D), ...
L L L L
Note:
L XL X = 0LX L0 = X X Y = Y X
(X Y) Z = X (Y Z)
Move forward: L
at C, take addr(B), XOR it with C’s link value (i.e., B D), yields
addr(D), and you can continue traversing the list.
Move backward: Similar
C++ Standard Template Library (STL)
Implementation of common data structures

I Available in C++ library, known as Standard Template Library
(STL)
I List, stack, queue,
I Generally these data structures are called containers or collections
WWW resources
I www.sgi.com/tech/stl
I www.cppreference.com/cppstl.html
Lists Using STL
Two popular implementation of the List ADT

I The vector provides a growable array implementation of the List
ADT
F Advantage: it is indexable in constant time
F Disadvantage: insertion and deletion are computationally expensive
I The list provides a doubly linked list implementation of the List
ADT
F Advantage: insertion and deletion are cheap provided that the
position of the changes are known
F Disadvantage: list is not easily indexable
Vector and list are class templates
I Can be instantiated with different type of items
Iterators
Insert and remove from the middle of the list

I Require the notion of a position
I In STL a position is represented by a nested type, iterator
I Example: list <string>:: iterator; vector<int>:: iterator
Iterator: Represents position in the container
Three Issues:
I How one gets an Iterator?
I What operations the iterators themselves can perform?
I Which LIST ADT methods require iterators as parameters?
Example: The Polynomial ADT
An ADT for single-variable polynomials
N
X
f (x) = ai xi
i=0
Array implementation
The Polynomial ADT
Multiplying two polynomials
P1 (x) = 10x1000 + 5x14 + 1
P2 (x) = 3x1990 − 2x1492 + 11x + 5

Implementation using a singly linked list
Stack ADT
Stack is a list where insert and remove take place only at the top
Operations: Constant time
I Push - inserts element on top of stack
I Pop - removes element from top of stack
I Top - returns element at top of stack
I Empty, size
LIFO (Last In First Out)
Stack Implementation
Singly Linked List

I Push - inserts the element at the front of the list
I Pop - deletes the element at the front of the list
I Top - returns the element at the front of the list
Array
I Back, push back, pop back implementation from vector
I theArray and topOfStack which is -1 for an empty stack
I Push - increment topOfStack and then set theArray[topOfStack] = x
I Pop - return the value to theArray[topOfStack] and then decrement
topOfStack
Stack Implementation (cont’d)
Applications of Stack
Balancing symbols
I Compiler checks for program syntax errors
I Every right brace, bracket, and parenthesis must correspond to its
left counterpart
I The sequence [()] is legal, but [(]) is wrong
Postfix Expressions
Infix to Postfix Conversion
Function calls
Balancing Symbols
Balancing symbols: ((()())(()))
Evaluation of Postfix Expressions
Infix expression: ((1 * 2) + 3) + (4 * 5)

Postfix expression: 1 2 * 3 + 4 5 * +
I Unambiguous (no need for parenthesis)
I Infix needs parenthesis or else implicit precedence specification to
avoid ambiguity
E.g. ”a + b * c” can be ”(a + b) * c” or ”a + (b * c)”
I Postfix expression evaluation uses stack
I E.g. Evaluate 1 2 * 3 + 4 5 * +
Rule of postfix expression evaluation
I When a number/operand is seen push it onto the stack
I When a operator is seen, the operator is applied to the two
numbers (symbols) that are popped from the stack, and
I Result is pushed onto the stack
Infix to Postfix Conversion
When an operand is read, place it onto the output

Operators are not immediately output, so save them somewhere
else which is stack
If a left parenthesis is encountered, stack it
Start with an initially empty stack
If we see a right parenthesis, pop the stack, writing symbols until
we encounter a left parenthesis which is popped but not output
If we see any other symbols, then we pop the entries from the
stack until we find an entry of lower priority. One exception is we
never remove a ”(” from the stack except when processing a ”)”
Finally, if we read the end of input, pop the stack until it is empty,
writing symbols onto the output
Infix to Postfix Conversion (Cont’d)
Infix: a + b * c + ( d * e + f ) * g
Postfix: a b c * + d e * f + g * +
Applications of Stack: Function Calls
Programming languages use stack to keep track of function calls

When a function call occurs
I Push CPU registers and program counter on to stack (activation
record or stack frame)
I Upon return, restore registers and program counter from top stack
frame and pop
Queue ADT
Queue is a list where insert takes place at the back, but remove
takes place at the front
Operations
I Enqueue - inserts element at the back of queue
I Dequeue - removes and returns element from the front of the queue
FIFO (First In First Out)
Queue Implementation of Array
When an item is enqueued, make the rear index move forward.

When an item is dequeued, the front index moves by one element
towards the back of the queue (thus removing the front item, so
no copying to neighboring elements is needed).
(front) XXXXOOOOO (rear)
OXXXXOOOO (after 1 dequeue, and 1 enqueue)
OOXXXXXOO after another dequeue, and 2 enqueues)
OOOOXXXXX (after 2 more dequeues, and 2 enqueues)
The problem here is that the rear index cannot move beyond the
last element in the array.
Using a circular array
I OOOOO7963 → 4OOOO7963 (after Enqueue(4))
Empty or Full?
Empty queue:
I back = front - 1
Full queue?
I the same!
I Reason: n values to represent n + 1 states
Solutions
I Use a boolean variable to say explicitly whether the queue is empty
or not
I Make the array of size n+1 and only allow n elements to be stored
I Use a counter of the number of elements in the queue
Queue Implementation based on Linked List
Queue Implementation based on Linked List (Cont’d)
Applications of Queue
Job scheduling, e.g., Jobs submitted to a line printer

Customer service calls are generally placed on a queue when all
operators are busy
Priority queues
Graph traversals
Queuing theory

Lists, Stacks, and Queues

Uploaded by

Copyright:

Available Formats

Lists, Stacks, and Queues

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lists, Stacks, and Queues

Uploaded by

Copyright:

Available Formats

Lists, Stacks, and Queues

A technique for developing a program in which the solution is

Languages supporting OOD include: C++, Java, Smalltalk, Eiffel,

A sequence of zero or more elements:

printList: print the list

Choose a data structure to represent the ADT. E.g. arrays, records,

Requires an estimate of the maximum size of the list – waste space

The list is not stored contiguously

A linked list is a series of connected nodes

Declare List, which contains

Doubly linked lists

insert(X, A): insert node A before X

Problems with operations at ends of list

Empty doubly-linked list with sentinel nodes

An XOR linked list compresses the same information into one L

Implementation of common data structures

Two popular implementation of the List ADT

Insert and remove from the middle of the list

Multiplying two polynomials

P1 (x) = 10x1000 + 5x14 + 1

P2 (x) = 3x1990 − 2x1492 + 11x + 5

Singly Linked List

Balancing symbols: ((()())(()))

Infix expression: ((1 * 2) + 3) + (4 * 5)

When an operand is read, place it onto the output

Programming languages use stack to keep track of function calls

When an item is enqueued, make the rear index move forward.

Job scheduling, e.g., Jobs submitted to a line printer

You might also like