Trees

1
Trees
2
Tree Basics

• A tree is a set of nodes.
• A tree may be empty (i.e., contain no nodes).
• If not empty, there is a distinguished node, r,
  called the root and zero or more non-empty
  subtrees T1, T2, T3,.Tk, each of whose roots is
  connected by a directed edge from r.
• Trees are recursive in their definition and,
  therefore, in their implementation.

3
A General Tree
A
B
G
K
L
C
D
H
I
J
E
F
4
Tree Terminology

• Tree terminology takes its terms from both nature
  and genealogy.
• A node directly below the root, r, of a subtree
  is a child of r, and r is called its parent.
• All children with the same parent are called
  siblings.
• A node with one or more children is called an
  internal node.
• A node with no children is called a leaf or
  external node.

5
Tree Terminology (cont)

• A path in a tree is a sequence of nodes, (N1, N2,
  Nk) such that Ni is the parent of Ni1 for 1 lt
  i lt k.
• The length of this path is the number of edges
  encountered (k 1).
• If there is a path from node N1 to N2, then N1 is
  an ancestor of N2 and N2 is a descendant of N1.

6
Tree Terminology (cont)

• The depth of a node is the length of the path
  from the root to the node.
• The height of a node is the length of the longest
  path from the node to a leaf.
• The depth of a tree is the depth of its deepest
  leaf.
• The height of a tree is the height of the root.
• True or False The height of a tree and the
  depth of a tree always have the same value.

7
Tree Storage

• First attempt - each tree node contains
• The data being stored
• We assume that the objects contained in the nodes
  support all necessary operations required by the
  tree.
• Links to all of its children
• Problem A tree node can have an indeterminate
  number of children. So how many links do we
  define in the node?

8
First Child, Next Sibling

• Since we cant know how many children a node can
  have, we cant create a static data structure --
  we need a dynamic one.
• Each node will contain
• The data which supports all necessary operations
• A link to its first child
• A link to a sibling

9
First Child, Next Sibling Representation

• To be supplied in class

10
Tree Traversal

• Traversing a tree means starting at the root and
  visiting each node in the tree in some orderly
  fashion. visit is a generic term that means
  perform whatever operation is applicable.
• Visiting might mean
• Print data stored in the tree
• Check for a particular data item
• Almost anything

11
Breadth-First Tree Traversals

• Start at the root.
• Visit all the roots children.
• Then visit all the roots grand-children.
• Then visit all the roots great-grand-children,
  and so on.
• This traversal goes down by levels.
• A queue can be used to implement this algorithm.

12
BF Traversal Pseudocode

• Create a queue, Q, to hold tree nodes
• Q.enqueue (the root)
• while (the queue is not empty)Node N
  Q.dequeue( )for each child, X, of N Q.enqueue
  (X)
• The order in which the nodes are dequeued is the
  BF traversal order.

13
Depth-First Traversal

• Start at the root.
• Choose a child to visit remember those not
  chosen
• Visit all of that childs children.
• Visit all of that childs childrens children,
  and so on.
• Repeat until all paths have been traversed
• This traversal goes down a path until the end,
  then comes back and does the next path.
• A stack can be used to implement this algorithm.

14
DF Traversal Pseudocode

• Create a stack, S, to hold tree nodes
• S.push (the root)
• While (the stack is not empty)Node N S.pop (
  )for each child, X, of N S.push (X)
• The order in which the nodes are popped is the DF
  traversal order.

15
Performance of BF and DF Traversals

• What is the asymptotic performance of
  breadth-first and depth-first traversals on a
  general tree?

16
Binary Trees

• A binary tree is a tree in which each node may
  have at most two children and the children are
  designated as left and right.
• A full binary tree is one in which each node has
  either two children or is a leaf.
• A perfect binary tree is a full binary tree in
  which all leaves are at the same level.

17
A Binary Tree
18
A binary tree? A full binary tree?
19
A binary tree? A full binary tree? A perfect
binary tree?
20
Binary Tree Traversals

• Because nodes in binary trees have at most two
  children (left and right), we can write
  specialized versions of DF traversal. These are
  called
• In-order traversal
• Pre-order traversal
• Post-order traversal

21
In-Order Traversal

• At each node
• visit my left child first
• visit me
• visit my right child last

8
5
3
7
9
12
15
6
2
10
22
In-Order Traversal Code
void inOrderTraversal(Node nodePtr) if
(nodePtr ! NULL) inOrderTraversal(nod
ePtr-gtleftPtr) cout ltlt nodePtr-gtdata ltlt endl
inOrderTraversal(nodePtr-gtrightPtr)

23
Pre-Order Traversal

• At each node
• visit me first
• visit my left child next
• visit my right child last

8
5
3
7
9
12
15
6
2
10
24
Pre-Order Traversal Code
void preOrderTraversal(Node nodePtr) if
(nodePtr ! NULL) cout ltlt
nodePtr-gtdata ltlt endl
preOrderTraversal(nodePtr-gtleftPtr)
preOrderTraversal(nodePtr-gtrightPtr)
25
Post-Order Traversal

• At each node
• visit my left child first
• visit my right child next
• visit me last

8
5
3
7
9
12
15
6
2
10
26
Post-Order Traversal Code
void postOrderTraversal(Node nodePtr) if
(nodePtr ! NULL) postOrderTraversal(n
odePtr-gtleftPtr) postOrderTraversal(nod
ePtr-gtrightPtr) cout ltlt nodePtr-gtdata
ltlt endl
27
Binary Tree Operations

• Recall that the data stored in the nodes supports
  all necessary operators. Well refer to it as a
  value for our examples.
• Typical operations
• Create an empty tree
• Insert a new value
• Search for a value
• Remove a value
• Destroy the tree

28
Creating an Empty Tree

• Set the pointer to the root node equal to NULL.

29
Inserting a New Value

• The first value goes in the root node.
• What about the second value?
• What about subsequent values?

• Since the tree has no properties which dictate
  where the values should be stored, we are at
  liberty to choose our own algorithm for storing
  the data.

30
Searching for a Value

• Since there is no rhyme or reason to where the
  values are stored, we must search the entire tree
  using a BF or DF traversal.

31
Removing a Value

• Once again, since the values are not stored in
  any special way, we have lots of choices.
  Example
• First, find the value via BF or DF traversal.
• Second, replace it with one of its descendants
  (if there are any).

32
Destroying the Tree

• We have to be careful of the order in which nodes
  are destroyed (deallocated).
• We have to destroy the children first, and the
  parent last (because the parent points to the
  children).
• Which traversal (in-order, pre-order, or
  post-order) would be best for this algorithm?

33
Giving Order to a Binary Tree

• Binary trees can be made more useful if we
  dictate the manner in which values are stored.
• When selecting where to insert new values, we
  could follow this rule
• left is less
• right is more
• Note that this assumes no duplicate nodes (i.e.,
  data).

34
Binary Search Trees

• A binary tree with the additional property that
  at each node,
• the value in the nodes left child is smaller
  than the value in the node itself, and
• the value in the nodes right child is larger
  than the value in the node itself.

35
A Binary Search Tree
50
57
42
67
30
53
22
34
36
Searching a BST

• Searching for the value X, given a pointer to the
  root
• If the value in the root matches, were done.
• If X is smaller than the value in the root, look
  in the roots left subtree.
• If X is larger than the value in the root, look
  in the roots right subtree.
• A recursive routine whats the base case?

37
Inserting a Value in a BST

• To insert value X in a BST
• Proceed as if searching for X.
• When the search fails, create a new node to
  contain X and attach it to the tree at that node.

38
Inserting
100 38 56 150 20 40 125 138 90
39
Removing a Value From a BST

• Non-trivial
• Three separate cases
• node is a leaf (has no children)
• node has a single child
• node has two children

40
Removing
100
150
50
70
120
30
130
80
60
40
20
85
65
55
53
57
41
Destroying a BST

• The fact that the values in the nodes are in a
  special order doesnt help.
• We still have to destroy each child before
  destroying the parent.
• Which traversal must we use?

42
Performance in a BST

• What is the asymptotic performance of
• insert
• search
• remove
• Is the performance of insert, search, and remove
  for a BST improved over that for a plain binary
  tree?
• If so, why?
• If not, why not?