Trees and Graphs

Trees, Binary Search Trees, Balanced

Trees, Graphs

Svetlin Nakov
Telerik
Corporation
www.telerik.
com
 Table of Contents
1. Tree-like Data Structures
2. Trees and Related Terminology
3. Implementing Trees
4. Traversing Trees
5. Balanced Trees
6. Graphs

2
 Tree-like Data
Structures
Trees, Balanced Trees, Graphs, Networks
 Tree-like Data
Structures
 Tree-like data structures are
 Branched recursive data structures
 Consisting of nodes
 Each node can be connected to other
nodes
 Examples of tree-like structures
 Trees: binary / other degree, balanced,
etc.
 Graphs: directed / undirected, weighted,
etc.
 Networks 4
 Tree-like Data
Structures
Netwo 5 (2
0)
2 5
Tre rk 1 10
(4
(1
0)
Project
e 0)

15 (15)
0)
Manager 20(2 6
) 3 5
(30 (5
Team De- QA Team 15 )
Leader signer Leader 4
5
Developer Developer Tester Tester
1 3 1 2

Developer 7
1
2 14
4
21
Gra 11
12 19
ph 31
5
Trees and Related
Terminology
Node, Edge, Root, Children,
Parent, Leaf , Binary Search Tree,
Balanced Tree
 Trees
 Tree data structure – terminology
 Node, edge, root, child, children,
siblings, parent, ancestor, descendant,
predecessor, successor, internal node,
leaf, depth, height, subtree
17 Depth 0

Height = 2 9 15 Depth 1
14

6 5 8 Depth 2

7
 Binary Trees
 Binary trees: most widespread form
 Each node has at most 2 children

Root
node Right
17
Left child
subtree Right
9 15
child
6 5 8 10

Left
child 8
 Binary Search Trees
 Binary search trees are ordered
 For each node x in the tree
 All the elements of the left subtree of x
are ≤ x
 All the elements of the right subtree of x
are > x
 Binary search trees can be balanced
 Balanced trees have height of ~ log2(x)
 Balanced trees have for each node
nearly equal number of nodes in its
subtrees 9
 Binary Search Trees (2)
 Example of balanced binary search
tree
17

9 19

6 12 25

 If the tree is balanced, add / search / delete

operations take approximately log(n) steps
10
Implementing Trees
Recursive Tree Data Structure
 Recursive Tree
Definition
 The recursive definition for tree
data structure:
 A single node is tree
 Tree nodes can have zero or
multiple children that are also trees
 Tree node definition
public class TreeNode<T>
Thein C#
value
{ contained in
private T value; the node
private List<TreeNode<T>> children;
…
List of child
}
nodes, which are
of the same type 12
 TreeNode<int> Structure
List<TreeNode<int>>
children

int TreeNode<in
7 children
value t>

19 children 21 children 14 children

1 children 31 children 23 children 6 children

12 children

13
 Implementing
TreeNode<T>
public TreeNode(T value)
{
this.value = value;
this.children = new List<TreeNode<T>>();
}
public T Value
{
get { return this.value; }
set { this.value = value; }
}
public void AddChild(TreeNode<T> child)
{
child.hasParent = true;
this.children.Add(child);
}
public TreeNode<T> GetChild(int index)
{
return this.children[index];
}
14
 Implementing Tree<T>
 The class Tree<T> keeps tree's root
node
public class Tree<T>
{
private TreeNode<T> root;
public Tree(T value, params Tree<T>[] children):
this(value)
{
foreach (Tree<T> child in children) Flexible
{
this.root.AddChild(child.root); constructor for
} building trees
}
public TreeNode<T> Root
{
get { return this.root; }
}
}
15
 Building a Tree
 Constructing tree by nested
constructors:
Tree<int> tree =
new Tree<int>(7,
7
new Tree<int>(19,
new Tree<int>(1),
new Tree<int>(12),
new Tree<int>(31)), 19 21 14
new Tree<int>(21),
new Tree<int>(14,
new Tree<int>(23),
1 12 31 23 6
new Tree<int>(6))
);

16
Tree Traversals
DFS and BFS Traversals
 Tree Traversal
Algorithms
 Traversing a tree means to visit each
of its nodes exactly one in particular
order
 Many traversal algorithms are known
 Depth-First Search (DFS)
 Visit node's successors first
 Usually implemented by recursion
 Breadth-First Search (BFS)
 Nearest nodes visited first
 Implemented by a queue
18
 Depth-First Search
(DFS)
 Depth-First Search first visits all
descendants of given node
recursively, finally visits the node
itself 9
 DFS algorithm pseudo code7
DFS(node)
{
4 5 8
for each child c of
19 21 14
node
DFS(c);
1 2 3 6 7
print the current node;
1 12 31 23 6
}

19
 DFS in Action (Step 1)
 Stack: 7
 Output: (empty)

19 21 14

1 12 31 23 6

20
 DFS in Action (Step 2)
 Stack: 7, 19
 Output: (empty)

19 21 14

1 12 31 23 6

21
 DFS in Action (Step 3)
 Stack: 7, 19, 1
 Output: (empty)

19 21 14

1 12 31 23 6

22
 DFS in Action (Step 4)
 Stack: 7, 19
 Output: 1

19 21 14

1 12 31 23 6

23
 DFS in Action (Step 5)
 Stack: 7, 19, 12
 Output: 1

19 21 14

1 12 31 23 6

24
 DFS in Action (Step 6)
 Stack: 7, 19
 Output: 1, 12

19 21 14

1 12 31 23 6

25
 DFS in Action (Step 7)
 Stack: 7, 19, 31
 Output: 1, 12

19 21 14

1 12 31 23 6

26
 DFS in Action (Step 8)
 Stack: 7, 19
 Output: 1, 12, 31

19 21 14

1 12 31 23 6

27
 DFS in Action (Step 9)
 Stack: 7
 Output: 1, 12, 31, 19

19 21 14

1 12 31 23 6

28
 DFS in Action (Step 10)
 Stack: 7, 21
 Output: 1, 12, 31, 19

19 21 14

1 12 31 23 6

29
 DFS in Action (Step 11)
 Stack: 7
 Output: 1, 12, 31, 19, 21

19 21 14

1 12 31 23 6

30
 DFS in Action (Step 12)
 Stack: 7, 14
 Output: 1, 12, 31, 19, 21

19 21 14

1 12 31 23 6

31
 DFS in Action (Step 13)
 Stack: 7, 14, 23
 Output: 1, 12, 31, 19, 21

19 21 14

1 12 31 23 6

32
 DFS in Action (Step 14)
 Stack: 7, 14
 Output: 1, 12, 31, 19, 21, 23

19 21 14

1 12 31 23 6

33
 DFS in Action (Step 15)
 Stack: 7, 14, 6
 Output: 1, 12, 31, 19, 21, 23

19 21 14

1 12 31 23 6

34
 DFS in Action (Step 16)
 Stack: 7, 14
 Output: 1, 12, 31, 19, 21, 23, 6

19 21 14

1 12 31 23 6

35
 DFS in Action (Step 17)
 Stack: 7
 Output: 1, 12, 31, 19, 21, 23, 6, 14

19 21 14

1 12 31 23 6

36
 DFS in Action (Step 18)
 Stack: (empty)
 Output: 1, 12, 31, 19, 21, 23, 6, 14, 7
Traversal
7 finished

19 21 14

1 12 31 23 6

37
 Breadth-First Search
(BFS)
 Breadth-First Search first visits the
neighbor nodes, later their
neighbors, etc.
 BFS algorithm pseudo code
BFS(node) 1

{ 7
queue  node
while queue not empty 2 3 4
v  queue 19 21 14
print v
for each child c of v 5 6 7 8 9
queue  c 1 12 31 23 6
}
38
 BFS in Action (Step 1)
 Queue: 7
 Output: 7

19 21 14

1 12 31 23 6

39
 BFS in Action (Step 2)
 Queue: 7, 19
 Output: 7

19 21 14

1 12 31 23 6

40
 BFS in Action (Step 3)
 Queue: 7, 19, 21
 Output: 7

19 21 14

1 12 31 23 6

41
 BFS in Action (Step 4)
 Queue: 7, 19, 21, 14
 Output: 7

19 21 14

1 12 31 23 6

42
 BFS in Action (Step 5)
 Queue: 7, 19, 21, 14
 Output: 7, 19

19 21 14

1 12 31 23 6

43
 BFS in Action (Step 6)
 Queue: 7, 19, 21, 14, 1
 Output: 7, 19

19 21 14

1 12 31 23 6

44
 BFS in Action (Step 7)
 Queue: 7, 19, 21, 14, 1, 12
 Output: 7, 19

19 21 14

1 12 31 23 6

45
 BFS in Action (Step 8)
 Queue: 7, 19, 21, 14, 1, 12, 31
 Output: 7, 19

19 21 14

1 12 31 23 6

46
 BFS in Action (Step 9)
 Queue: 7, 19, 21, 14, 1, 12, 31
 Output: 7, 19, 21

19 21 14

1 12 31 23 6

47
 BFS in Action (Step 10)
 Queue: 7, 19, 21, 14, 1, 12, 31
 Output: 7, 19, 21, 14

19 21 14

1 12 31 23 6

48
 BFS in Action (Step 11)
 Queue: 7, 19, 21, 14, 1, 12, 31, 23
 Output: 7, 19, 21, 14

19 21 14

1 12 31 23 6

49
 BFS in Action (Step 12)
 Queue: 7, 19, 21, 14, 1, 12, 31, 23, 6
 Output: 7, 19, 21, 14

19 21 14

1 12 31 23 6

50
 BFS in Action (Step 13)
 Queue: 7, 19, 21, 14, 1, 12, 31, 23, 6
 Output: 7, 19, 21, 14, 1

19 21 14

1 12 31 23 6

51
 BFS in Action (Step 14)
 Queue: 7, 19, 21, 14, 1, 12, 31, 23, 6
 Output: 7, 19, 21, 14, 1, 12

19 21 14

1 12 31 23 6

52
 BFS in Action (Step 15)
 Queue: 7, 19, 21, 14, 1, 12, 31, 23, 6
 Output: 7, 19, 21, 14, 1, 12, 31

19 21 14

1 12 31 23 6

53
 BFS in Action (Step 16)
 Queue: 7, 19, 21, 14, 1, 12, 31, 23, 6
 Output: 7, 19, 21, 14, 1, 12, 31, 23

19 21 14

1 12 31 23 6

54
 BFS in Action (Step 16)
 Queue: 7, 19, 21, 14, 1, 12, 31, 23, 6
 Output: 7, 19, 21, 14, 1, 12, 31, 23, 6

19 21 14

1 12 31 23 6

55
 BFS in Action (Step 17)
 Queue: 7, 19, 21, 14, 1, 12, 31, 23, 6
 The
Output: 7, 19, 21, 14, 1, 12, 31, 23 ,6
queue
is
7 empty
 stop

19 21 14

1 12 31 23 6

56
 Binary Trees DFS
Traversals
 DFS traversal of binary trees can be done
in pre-order, in-order and post-order

17

9 19

6 12 25
 Pre-order: left, root, right  6, 9, 12, 17, 19, 25
 In-order: root, left, right  17, 9, 6, 12, 19, 25
 Post-order: left, right, root  6, 12, 9, 25, 19,
17
57
 Iterative DFS and BFS
 What will happen if in the Breadth-
First Search (BFS) algorithm a stack
is used instead of queue?
 An iterative Depth-First Search (DFS) –
BFS(node) DFS(node)
{ in-order {
queue  node stack  node
while queue not empty while stack not empty
v  queue v  stack
print v print v
for each child c of for each child c of
v v
queue  c stack  c
} } 58
Trees and Traversals
Live Demo
 Balanced Search
Trees
AVL Trees, B-Trees, Red-Black Trees, AA-
Trees
 Balanced Binary Search
Trees
 Ordered Binary Trees (Binary Search
Trees)
 For each node x the left subtree has values
≤ x and the right subtree has values > x
 Balanced Trees
 For each node its subtrees contain nearly
equal number of nodes  nearly the same
height
 Balanced Binary Search Trees
 Ordered binary search trees that have
height of log2(n) where n is the number of
their nodes
 Searching costs about log2(n) comparisons 61
 Balanced Binary Search
Tree – Example
33

18 54

15 24 42 60

3 17 20 29 37 43 59 85

62
 Balanced Binary Search
Trees
 Balanced binary search trees are hard to
implement
 Rebalancing the tree after insert / delete is
complex
 Well known implementations of balanced
binary search trees
 AVL trees – ideally balanced, very complex
 Red-black trees – roughly balanced, more
simple
 AA-Trees – relatively simple to implement
 Find / insert / delete operations need log2(n)
steps 63
 B-Trees
 B-trees are generalization of the concept
of ordered binary search trees
 B-tree of order d has between d and 2*d
keys in a node and between d+1 and 2*d+1
child nodes
 The keys in each node are ordered
increasingly
 All keys in a child node have values
between their left and right parent keys
 If the b-tree is balanced, its search / insert
/ add operations take about log(n) steps
 B-trees can be efficiently stored on the

disk 64
 B-Tree – Example
 B-Tree of order 2, also known as 2-3-
4-tree:
17 21

1 1 2 2 3
7
1 8 0 6 1

1 1 2 2 2 2 2 3
2 4 5 6 8 9 32 35
2 6 2 3 5 7 9 0

65
 Balanced Trees in .NET
 .NET Framework has several built-in
implementations of balanced search
trees:
 SortedDictionary<K,V>
 Red-black tree based map of key-value
pairs
 OrderedSet<T>
 Red-black tree based set of elements
 External libraries like "Wintellect Power
Collections for .NET" are more flexible
 http://powercollections.codeplex.com
66
 Graphs
Definitions, Representation, Traversal
Algorithms
 Graph Data Structure
 Set of nodes with many-to-many
relationship between them is called
graph
 Each node has multiple predecessors
Node
 Each node has multiple successors
with
Node with
multiple multiple
predecessors 7 success
1
14 ors
4
21

11
12 19 31
68
 Graph Definitions
 Node (vertex)
Node
 Element of graph
 Can have name or value A
 Keeps a list of adjacent nodes
 Edge
Edge
 Connection between two nodes
 Can be directed / undirected
A B
 Can be weighted / unweighted
 Can have name / value
69
 Graph Definitions (2)
 Directed graph  Undirected
 Edges have direction graph
 Undirected
22 edges
2
3 A F

7 J
1
4
D
G
21
12
E C H
19
3

70
 Graph Definitions (3)
 Weighted graph
 Weight (cost) is associated with
each edge
10
A F 4
5 N
6 8
J
16
Q
7 22
D
9 G
3
14 K
E C H
71
 Graph Definitions (4)
 Path (in undirected graph)
 Sequence of nodes n1, n2, … nk
 Edge exists between each pair of
nodes ni, ni+1
 Examples:
B C
 A, B, C is a path
 H, K, C is not a path A G K

H N

72
 Graph Definitions (5)
 Path (in directed graph)
 Sequence of nodes n1, n2, … nk
 Directed edge exists between each
pair of nodes ni, ni+1
 Examples:
B C
 A, B, C is a path
 A, G, K is not a pathA G K

H N

73
 Graph Definitions (6)
 Cycle
 Path that ends back at the starting
node
 Example:
B
 A, B, C, G, A C

 Simple path A G K
 No cycles in path
H N
 Acyclic graph
 Graph with no cycles
 Acyclic undirected graphs are trees 74
 Graph Definitions (8)
 Two nodes are reachableUnconnecte
if
d graph
 Path exists between themwith two
connected
 Connected graph
component
 Every node is reachable froms any
Every node is reachable from any
other node
Connected
graph A F
J
A F
J D G
D G E H
C

75
 Graphs and Their
Applications
 Graphs have many real-world applications
 Modeling a computer network like Internet
 Routes are simple paths in the network
 Modeling a city map
 Streets are edges, crossings are vertices
 Social networks
 People are nodes and their connections are
edges
 State machines
 States are nodes, transitions are edges

76
 Representing Graphs
 Adjacency list 1  {2,
4} 3 2
 Each node holds a 2  {3}
3  {1}
list of its
4  {2} 1 4
neighbors

1 2 3 4
 Adjacency matrix 1 0 1 0 1
 Each cell keeps 2 0 0 1 0
3 1 0 0 0
whether and how
4 0 1 0 0
two nodes are
connected
{1,2} {1,4} {2,3} {3,1}
{4,2}
 Set of edges 77
 Representing Graphs in
C#
public class Graph 0
{ 6
int[][] childNodes; 3
public Graph(int[][]
nodes) 1
{ 4
this.childNodes = nodes; 5
} 2
}
Graph g = new Graph(new int[][] {
new int[] {3, 6}, // successors of vertice 0
new int[] {2, 3, 4, 5, 6}, // successors of
vertice 1
new int[] {1, 4, 5}, // successors of vertice 2
new int[] {0, 1, 5}, // successors of vertice 3
new int[] {1, 2, 6}, // successors of vertice 4
new int[] {1, 2, 3}, // successors of vertice 5
new int[] {0, 1, 4} // successors of vertice 6
}); 78
 Graph Traversal
Algorithms
 Depth-First Search (DFS) and
Breadth-First Search (BFS) can
traverse graphs
 Each
BFS( node) vertex should be
DFS(is visited
node ) at
{ most once {
queue  node stack  node
visited[node] = true visited[node] = true
while queue not empty while stack not empty
v  queue v  stack
print v print v
for each child c of for each child c of
v v
if not visited[c] if not visited[c]
queue  c stack  c
visited[c] = visited[c] =
true true 79
 Recursive DFS Graph
Traversal
void TraverseDFSRecursive(node)
{
if (not visited[node])
{
visited[node] = true
print node
foreach child node c of node
{
TraverseDFSRecursive(c);
}
}
}

vois Main()
{
TraverseDFS(firstNode);
}

80
Graphs and Traversals
Live Demo
 Summary
 Trees are recursive data structure – node
with set of children which are also nodes
 Binary Search Trees are ordered binary
trees
 Balanced trees have weight of log(n)
 Graphs are sets of nodes with many-to-
many relationship between them
 Can be directed/undirected, weighted /
unweighted, connected / not connected, etc.
 Tree / graph traversals can be done by
Depth-First Search (DFS) and Breadth-
First Search (BFS) 82
 Trees and Graphs

Questions?

http://academy.telerik.com
 Exercises
1. Write a program to traverse the directory C:\
WINDOWS and all its subdirectories recursively
and to display all files matching the mask
*.exe. Use the class System.IO.Directory.
2. Define classes File { string name, int size }
and Folder { string name, File[] files, Folder[]
childFolders } and using them build a tree
keeping all files and folders on the hard drive
starting from C:\WINDOWS. Implement a
method that calculates the sum of the file
sizes in given subtree of the tree and test it
accordingly. Use recursive DFS traversal.
84
 Exercises (2)
3. Implement the recursive Depth-First-Search
(DFS) traversal algorithm. Test it with the
sample graph from the demonstrations.
4. Implement the queue-based Breath-First-
Search (BFS) traversal algorithm. Test it with
the sample graph from the demonstrations.
5. Write a program for finding all cycles in given
undirected graph using recursive DFS.
6. Write a program for finding all connected
components of given undirected graph. Use a
sequence of DFS traversals.

85
 Exercises (3)
7. Write a program for finding the shortest path
between two vertices in a weighted directed
graph. Hint: Use the Dijkstra's algorithm.
8. We are given a set of N tasks that should be
executed in a sequence. Some of the tasks
depend on other tasks. We are given a list of
tasks { ti, tj} where tj depends on the result
of ti and should be executed after it. Write a
program that arranges the tasks in a
sequence so that each task depending on
another task is executed after it. If such
arrangement is impossible indicate this fact.
Example: {1, 2}, {2, 5}, {2, 4}, {3, 1}  3, 1,
2, 5, 4 86