Data Structures
and Algorithms
Data Structures and Algorithms
2
2.2 Outline
This topic will describe:
– The concrete data structures that can be used to store information
– The basic forms of memory allocation
• Contiguous
• Linked
• Indexed
– The prototypical examples of these: arrays and linked lists
– Other data structures:
• Trees
• Hybrids
• Higher-dimensional arrays
– Finally, we will discuss the run-time of queries and operations on arrays
and linked lists
Data Structures and Algorithms
3
2.2.1 Memory Allocation
Memory allocation can be classified as either
– Contiguous
– Linked
– Indexed
Prototypical examples:
– Contiguous allocation: arrays
– Linked allocation: linked lists
Data Structures and Algorithms
4
2.2.1.1 Memory Allocation
Contiguous, adj.
Touching or connected throughout in an unbroken sequence.
Meriam Webster
Touching, in actual contact, next in space; meeting at a common
boundary, bordering, adjoining.
www.oed.com
Data Structures and Algorithms
5
2.2.1.1
2.2.1 Contiguous Allocation
An array stores n objects in a single contiguous space of memory
Unfortunately, if more memory is required, a request for new
memory usually requires copying all information into the new
memory
– In general, you cannot request for the operating
system to allocate to you the next n memory
locations
Data Structures and Algorithms
6
2.2.1.2 Linked Allocation
Linked storage such as a linked list associates two pieces of data
with each item being stored:
– The object itself, and
– A reference to the next item
• In C++ that reference is the address of the next node
Data Structures and Algorithms
7
2.2.1.2 Linked Allocation
This is a class describing such a node
template <typename Type>
class Node {
private:
Type element;
Node *next_node;
public:
// ...
};
Data Structures and Algorithms
8
2.2.1.2 Linked Allocation
The operations on this node must include:
– Constructing a new node
– Accessing (retrieving) the value
– Accessing the next pointer
Node( const Type& = Type(), Node* = nullptr );
Type retrieve() const;
Node *next() const;
Data Structures and Algorithms
9
2.2.1.2 Linked Allocation
For a linked list, however, we also require an object which links to
the first object
The actual linked list class must store two pointers
– A head and tail:
Node *head;
Node *tail;
Optionally, we can also keep a count
int count;
The next_node of the last node is assigned nullptr
Data Structures and Algorithms
10
2.2.1.2 Linked Allocation
The class structure would be:
template <typename Type>
class List {
private:
Node<Type> *head;
Node<Type> *tail;
int count;
public:
// constructor(s)...
// accessor(s)...
// mutator(s)...
};
Data Structures and Algorithms
11
2.2.1.3 Indexed Allocation
With indexed allocation, an array of pointers
(possibly NULL) link to a sequence of allocated
memory locations
Data Structures and Algorithms
12
2.2.1.3 Indexed Allocation
Matrices can be implemented using indexed allocation:
1 2 3
4 5 6
Data Structures and Algorithms
13
2.2.1.3 Indexed Allocation
Matrices can be implemented using indexed allocation
– Most implementations of matrices (or higher-dimensional arrays) use
indices pointing into a single contiguous block of memory
Row-major order Column-major order
1 2 3
4 5 6
Data Structures and Algorithms
14
2.2.2 Other Allocation Formats
We will look at some variations or hybrids of these memory
allocations including:
– Trees
– Graphs
– Deques (linked arrays)
– inodes
Data Structures and Algorithms
15
2.2.2.2 Trees
The linked list can be used to store linearly ordered data
– What if we have multiple next pointers?
A rooted tree is similar
to a linked list but with multiple next
pointers
Data Structures and Algorithms
16
2.2.2.2 Trees
A tree is a variation on a linked list:
– Each node points to an arbitrary number of subsequent nodes
– Useful for storing hierarchical data
– We will see that it is also useful for storing sorted data
– Usually we will restrict ourselves to trees where each node points to at
most two other nodes
Data Structures and Algorithms
17
2.2.2.2 Graphs
Suppose we allow arbitrary relations between any two objects in a
container
– Given n objects, there are n2 – n possible relations
n2 n
• If we allow symmetry, this reduces to
2
– For example, consider the network
Data Structures and Algorithms
18
2.2.2.2 Arrays
Suppose we allow arbitrary relations between any two objects in a
container
– We could represent this using a two-dimensional array
– In this case, the matrix is A B C D E F G H I J K L
symmetric A × × ×
B × × × × ×
C × × × × × ×
D × × ×
E × ×
F × ×
G × × ×
H × × ×
I × ×
J × × ×
K × × ×
L × × ×
Data Structures and Algorithms
19
2.2.2.2 Array of Linked Lists
Suppose we allow arbitrary relations between any two objects in a
container
– Alternatively, we could use a hybrid: an array of linked lists
A
B
C
D
E
F
G
H
I
J
K
L
Data Structures and Algorithms
20
2.2.2.3 Linked Arrays
Other hybrids are linked lists of arrays
For example, the alphabet could be stored either as:
– An array of 26 entries, or
– A linked list of arrays of 8 entries
Data Structures and Algorithms
21
2.2.3 Algorithm run times
Once we have chosen a data structure to store both the objects and
the relationships, we must implement the queries or operations as
algorithms
– The Abstract Data Type will be implemented as a class
– The data structure will be defined by the member variables
– The member functions will implement the algorithms
The question is, how do we determine the efficiency of the
algorithms?
Data Structures and Algorithms
22
2.2.3 Operations
We will us the following matrix to describe operations at the
locations within the structure
Arbitrary
Front/1st Back/nth
Location
Find ? ? ?
Insert ? ? ?
Erase ? ? ?
Data Structures and Algorithms
23
2.2.3.1 Operations on Sorted Lists
Given an sorted array, we have the following run times:
Arbitrary
Front/1st Back/nth
Location
Find Good Okay Good
Insert Bad Bad Good* Bad
Erase Bad Bad Good
* only if the array is not full
Data Structures and Algorithms
24
2.2.3.2 Operations on Lists
If the array is not sorted, only one operations changes:
Arbitrary
Front/1st Back/nth
Location
Find Good Bad Good
Insert Bad Bad Good* Bad
Erase Bad Bad Good
* only if the array is not full
Data Structures and Algorithms
25
2.2.3.3 Operations on Lists
However, for a singly linked list where we a head and tail pointer, we
have:
Arbitrary
Front/1st Back/nth
Location
Find Good Bad Good
Insert Good Bad Good
Erase Good Bad Bad
Data Structures and Algorithms
26
2.2.3.3 Operations on Lists
If we have a pointer to the kth entry, we can insert or erase at that
location quite easily
Arbitrary
Front/1st Back/nth
Location
Find Good Bad Good
Insert Good Good Good
Erase Good Good Bad
Data Structures and Algorithms
27
2.2.3.4 Operations on Lists
For a doubly linked list, one operation becomes more efficient:
Arbitrary
Front/1st Back/nth
Location
Find Good Bad Good
Insert Good Good Good
Erase Good Good Good
