1

Trees

• A Quick Introduction to Graphs

• Definition of Trees

• Rooted Trees

• Binary Trees

• Binary Search Trees

2

Introduction to Graphs

• A graph is a finite set of nodes with edges between nodes

• Formally, a graph G is a structure (V,E) consisting of – a finite set V called the set of nodes, and– a set E that is a subset of VxV. That is, E is a set

of pairs of the form (x,y) where x and y are nodes in V

3

Examples of Graphs

• V={1,2,3,4,5}

• E={(1,2), (2,3), (2,4), (4,2), (3,3), (5,4)}

12

5

3

4

When (x,y) is an edge,we say that x is adjacent to y. 1 is adjacent to 2.2 is not adjacent to 1.4 is not adjacent to 3.

4

A “Real-life” Example of a Graph

• V=set of 6 people: John, Mary, Joe, Helen, Tom, and Paul, of ages 12, 15, 12, 15, 13, and 13, respectively.

• E ={(x,y) | if x is younger than y}

John Joe

Mary Helen

Tom Paul

5

Intuition Behind Graphs

• The nodes represent entities (such as people, cities, computers, words, etc.)

• Edges (x,y) represent relationships between entities x and y, such as:– “x loves y”

– “x hates y”

– “x is as smart as y”

– “x is a sibling of y”

– “x is bigger than y”

– ‘x is faster than y”, …

6

Directed vs. Undirected Graphs

• If the directions of the edges matter, then we show the edge directions, and the graph is called a directed graph (or a digraph)

• The previous two examples are digraphs• If the relationships represented by the edges

are symmetric (such as (x,y) is edge if and only if x is a sibling of y), then we don’t show the directions of the edges, and the graph is called an undirected graph.

7

Examples of Undirected Graphs

• V=set of 6 people: John, Mary, Joe, Helen, Tom, and Paul, where the first 4 are siblings, and the last two are siblings

• E ={(x,y) | x and y are siblings}

John Joe

Mary Helen

Tom Paul

8

Definition of Some Graph Related Concepts (Paths)

• A path in a graph G is a sequence of nodes x1, x2, …,xk, such that there is an edge from each node the next one in the sequence

• For example, in the first example graph, the sequence 4, 1, 2, 3 is a path, but the sequence 1, 4, 5 is not a path because (1,4) is not an edge

• In the “sibling-of” graph, the sequence John, Mary, Joe, Helen is a path, but the sequence Helen, Tom, Paul is not a path

9

Definition of Some Graph Related Concepts (Cycles)

• A cycle in a graph G is a path where the last node is the same as the first node.

• In the “sibling-of” graph, the sequence John, Mary, Joe, Helen, John is a cycle, but the sequence Helen, Tom, Paul, Helen is not a cycle

10

Graph Connectivity

• An undirected graph is said to be connected if there is a path between every pair of nodes. Otherwise, the graph is disconnected

• Informally, an undirected graph is connected if it hangs in one piece

Disconnected Connected

11

Graph Cyclicity

• An undirected graph is cyclic if it has at least one cycle. Otherwise, it is acyclic

Disconnected and acyclic Connected and acyclic

Disconnected and cyclic Connected and cyclic

12

Trees

• A tree is a connected acyclic undirected graph. The following are three trees:

1

2

53 11

12

10

98

7

64

13

Rooted Trees

• A rooted tree is a tree where one of the nodes is designated as the root node. (Only one root in a tree)

• A rooted tree has a hierarchical structure: the root on top, followed by the nodes adjacent to it right below, followed by the nodes adjacent to those next, and so on.

14

Example of a Rooted Tree

1

2

53 11

12

10

98

7

64

1

23

10

11

98

4 6

5

7

12Un-rooted tree

Tree rooted with root 1

15

Tree-Related Concepts

• The nodes adjacent to x and below x are called the children of x,and x is called their parents

• A node that has no children is called a leaf

• The descendents of a node are: itself, its children, their children, all the way down

• The ancestors of a node are: itself, its parent, its grandparent, all the way to the root

1

23

10

11

98

4 6

5

7

12

16

Tree-Related Concepts (Contd.)

• The depth of a node is the number of edges from the root to that node.

• The depth (or height) of

a rooted tree is the depth

of the lowest leaf

• Depth of node 10: 3

• Depth of this tree: 4

1

23

10

11

98

4 6

5

7

12

17

Binary Trees

• A tree is a binary tree if every node has at most two children

1

23

10

11

98

4 6

5

7

12

1

3

10

11

98

4 6

5

7

12

Non-binary tree Binary tree

18

Binary-Tree Related Definitions

• The children of any node in a binary tree are ordered into a left child and a right child

• A node can have a left anda right child, a left childonly, a right child only,or no children

• The tree made up of a leftchild (of a node x) and all itsdescendents is called the left subtree of x

• Right subtrees are defined similarly

10

1

3

11

98

4 6

5

7

12

19

Graphical View Binary-tree Nodes

data

left right

In practice, a TreeNode will be shown as a circle where the data is put inside, and the node label(if any) is put outside.

Graphically, a TreeNode is:

5.8 2data label

• A binary-tree node consists of 3 parts:

-Data-Pointer to left child-Pointer to right child

20

A Binary-tree Node Classclass TreeNode { public: typedef int datatype; TreeNode(datatype x=0, TreeNode *left=NULL,

TreeNode *right=NULL){data=x; this->left=left; this->right=right; };

datatype getData( ) {return data;};

TreeNode *getLeft( ) {return left;};

TreeNode *getRight( ) {return right;};void setData(datatype x) {data=x;};void setLeft(TreeNode *ptr) {left=ptr;};void setRight(TreeNode *ptr) {right=ptr;};

private:datatype data; // different data type for other appsTreeNode *left; // the pointer to left childTreeNode *right; // the pointer to right child

};

21

Binary Tree Class

class Tree { public: typedef int datatype; Tree(TreeNode *rootPtr=NULL){this->rootPtr=rootPtr;}; TreeNode *search(datatype x); bool insert(datatype x); TreeNode * remove(datatype x); TreeNode *getRoot(){return rootPtr;}; Tree *getLeftSubtree(); Tree *getRightSubtree(); bool isEmpty(){return rootPtr == NULL;}; private: TreeNode *rootPtr;};

22

Binary Search Trees

• A binary search tree (BST) is a binary tree where– Every node holds a data value (called key)– For any node x, all the keys in the left subtree

of x are ≤ the key of x– For any node x, all the keys in the right subtree

of x are > the key of x

23

Example of a BST

6

15

8

2

3 7

11

10

14

12

20

27

22 30

24

Searching in a BST

To search for a number b:

1. Compare b with the root;– If b=root, return

– If b<root, go left

– If b>root, go right

2. Repeat step 1, comparing b with the new node we are at.

3. Repeat until either the node is found or we reach a non-existing node

Try it with b=12, and also with b=17

6

158

2

3 7

11

10

14

12

20

27

22 30

25

Code for Search in BST

// returns a pointer to the TreeNode that contains x,// if one is found. Otherwise, it returns NULLTreeNode * Tree::search(datatype x){ if (isEmpty()) {return NULL;} TreeNode *p=rootPtr; while (p != NULL){ datatype a = p->getData(); if (a == x) return p; else if (x<a) p=p->getLeft(); else p=p->getRight(); } return NULL;};

26

Insertion into a BST

Insert(datatype b, Tree T):

1. Search for the position of b as if it were in the tree. The position is the left or right child of some node x.

2. Create a new node, and assign its address to the appropriate pointer field in x

3. Assign b to the data field of the new node

27

Illustration of Insert

6

158

2

3 7

11

10

14

12

20

27

22 30

Before inserting 25

6

158

2

3 7

11

10

14

12

20

27

22 30

25

After inserting 25

28

Code for Insert in BST

bool Tree::insert(datatype x){ if (isEmpty()) {rootPtr = new TreeNode(x);return true; } TreeNode *p=rootPtr; while (p != NULL){ datatype a = p->getData(); if (a == x) return false; // data is already there else if (x<a){ if (p->getLeft() == NULL){ // place to insert TreeNode *newNodePtr= new TreeNode(x); p->setLeft(newNodePtr); return true;} else p=p->getLeft(); }else { // a>a if (p->getRight() == NULL){ // place to insert TreeNode *newNodePtr= new TreeNode(x); p->setRight(newNodePtr); return true;} else p=p->getRight();} } };

29

Deletion from a BST (pseudocode)

Delete (datatype b, Tree T)1. Search for b in tree T. If not found, return.2. Call x the first node found to contain b3. If x is a leaf, remove x and set the

appropriate pointer in the parent of x to NULL

4. If x has only one child y, remove x, and the parent of x become a direct parent of y

(More on the next slide)

30

Deletion (contd.)

5. If x has two children, go to the left subtree, and find there in largest node, and call it y. The node y can be found by tracing the rightmost path until the end. Note that y is either a leaf or has no right child

6. Copy the data field of y onto the data field of x

7. Now delete node y in a manner similar to step 4.

31

Tree Traversal Techniques; Heaps

• Tree Traversal Concept• Tree Traversal Techniques: Preorder,

In-order, Post-order• Full Trees • Almost Complete Trees• Heaps

32

Binary-Tree Related Definitions

• The children of any node in a binary tree are ordered into a left child and a right child

• A node can have a left anda right child, a left childonly, a right child only,or no children

• The tree made up of a leftchild (of a node x) and all itsdescendents is called the left subtree of x

• Right subtrees are defined similarly

10

1

3

11

98

4 6

5

7

12

33

A Binary-tree Node Classclass TreeNode { public: typedef int datatype; TreeNode(datatype x=0, TreeNode *left=NULL,

TreeNode *right=NULL){data=x; this->left=left; this->right=right; };

datatype getData( ) {return data;};

TreeNode *getLeft( ) {return left;};

TreeNode *getRight( ) {return right;};void setData(datatype x) {data=x;};void setLeft(TreeNode *ptr) {left=ptr;};void setRight(TreeNode *ptr) {right=ptr;};

private:datatype data; // different data type for other appsTreeNode *left; // the pointer to left childTreeNode *right; // the pointer to right child

};

34

Binary Tree Class

class Tree { public: typedef int datatype; Tree(TreeNode *rootPtr=NULL){this->rootPtr=rootPtr;}; TreeNode *search(datatype x); bool insert(datatype x); TreeNode * remove(datatype x); TreeNode *getRoot(){return rootPtr;}; Tree *getLeftSubtree(); Tree *getRightSubtree(); bool isEmpty(){return rootPtr == NULL;}; private: TreeNode *rootPtr;};

35

Binary Tree Traversal

• Traversal is the process of visiting every node once

• Visiting a node entails doing some processing at that node, but when describing a traversal strategy, we need not concern ourselves with what that processing is

36

Binary Tree Traversal Techniques

• Three recursive techniques for binary tree traversal

• In each technique, the left subtree is traversed recursively, the right subtree is traversed recursively, and the root is visited

• What distinguishes the techniques from one another is the order of those 3 tasks

37

Preoder, Inorder, Postorder

• In Preorder, the root

is visited before (pre)

the subtrees traversals• In Inorder, the root is

visited in-between left

and right subtree traversal• In Preorder, the root

is visited after (pre)

the subtrees traversals

Preorder Traversal:1. Visit the root2. Traverse left subtree3. Traverse right subtree

Inorder Traversal:1. Traverse left subtree2. Visit the root3. Traverse right subtree

Postorder Traversal:1. Traverse left subtree2. Traverse right subtree3. Visit the root

38

Illustrations for Traversals

• Assume: visiting a node is printing its label

• Preorder: 1 3 5 4 6 7 8 9 10 11 12

• Inorder:4 5 6 3 1 8 7 9 11 10 12

• Postorder:4 6 5 3 8 11 12 10 9 7 1

1

3

11

98

4 6

5

7

12

10

39

Illustrations for Traversals (Contd.)

• Assume: visiting a node is printing its data

• Preorder: 15 8 2 6 3 711 10 12 14 20 27 22 30

• Inorder: 2 3 6 7 8 10 1112 14 15 20 22 27 30

• Postorder: 3 7 6 2 10 1412 11 8 22 30 27 20 15

6

158

2

3 7

11

10

14

12

20

27

22 30

40

Code for the Traversal Techniques• The code for visit

is up to you to

provide, depending

on the application

• A typical example

for visit(…) is to

print out the data

part of its input

node

void inOrder(Tree *tree){ if (tree->isEmpty( )) return; inOrder(tree->getLeftSubtree( )); visit(tree->getRoot( )); inOrder(tree->getRightSubtree( ));}

void preOrder(Tree *tree){ if (tree->isEmpty( )) return; visit(tree->getRoot( )); preOrder(tree->getLeftSubtree()); preOrder(tree->getRightSubtree());}

void postOrder(Tree *tree){ if (tree->isEmpty( )) return; postOrder(tree->getLeftSubtree( )); postOrder(tree->getRightSubtree( )); visit(tree->getRoot( ));}

41

Application of Traversal Sorting a BST

• Observe the output of the in-order traversal of the BST example two slides earlier

• It is sorted

• This is no coincidence

• As a general rule, if you output the keys (data) of the nodes of a BST using inorder traversal, the data comes out sorted in increasing order

42

Other Kinds of Binary Trees(Full Binary Trees)

• Full Binary Tree: A full binary tree is a binary tree where all the leaves are on the same level and every non-leaf has two children

• The first four full binary trees are:

43

Examples of Non-Full Binary Trees

• These trees are NOT full binary trees: (do you know why?)

44

Canonical Labeling ofFull Binary Trees

• Label the nodes from 1 to n from the top to the bottom, left to right

1 1

2 3

12 3

4 5 6 71

2 3

4 5 6 7

8 9 10 111213 14 15

Relationships between labelsof children and parent:

2i 2i+1i

45

Other Kinds of Binary Trees(Almost Complete Binary trees)

• Almost Complete Binary Tree: An almost complete binary tree of n nodes, for any arbitrary nonnegative integer n, is the binary tree made up of the first n nodes of a canonically labeled full binary

1 1

21

2 3

4 5 6 7

1

2

1

2 3

4 5 6

1

2 3

4

1

2 3

4 5

46

Depth/Height of Full Trees and Almost Complete Trees

• The height (or depth ) h of such trees is O(log n)• Proof: In the case of full trees,

– The number of nodes n is: n=1+2+22+23+…+2h=2h+1-1

– Therefore, 2h+1 = n+1, and thus, h=log(n+1)-1

– Hence, h=O(log n)

• For almost complete trees, the proof is left as an exercise.

47

Canonical Labeling ofAlmost Complete Binary Trees

• Same labeling inherited from full binary trees

• Same relationship holding between the labels of children and parents:

Relationships between labelsof children and parent:

2i 2i+1i

48

Array Representation of Full Trees and Almost Complete Trees

• A canonically label-able tree, like full binary trees and almost complete binary trees, can be represented by an array A of the same length as the number of nodes

• A[k] is identified with node of label k• That is, A[k] holds the data of node k• Advantage:

– no need to store left and right pointers in the nodes save memory

– Direct access to nodes: to get to node k, access A[k]

49

Illustration of Array Representation

• Notice: Left child of A[5] (of data 11) is A[2*5]=A[10] (of data 18),

and its right child is A[2*5+1]=A[11] (of data 12). • Parent of A[4] is A[4/2]=A[2], and parent of A[5]=A[5/2]=A[2]

6

158

2 11

18 12

20

27

13

30

15 8 20 2 11 30 27 13 6 10 121 2 3 4 5 6 7 8 9 10 11

50

Adjustment of Indexes

• Notice that in the previous slides, the node labels start from 1, and so would the corresponding arrays

• But in C/C++, array indices start from 0• The best way to handle the mismatch is to adjust the

canonical labeling of full and almost complete trees.• Start the node labeling from 0 (rather than 1).• The children of node k are now nodes (2k+1) and

(2k+2), and the parent of node k is (k-1)/2, integer division.

51

Application of Almost Complete Binary Trees: Heaps

• A heap (or min-heap to be precise) is an almost complete binary tree where– Every node holds a data value (or key)– The key of every node is ≤ the keys of the

children

Note:A max-heap has the same definition except that the Key of every node is >= the keys of the children

52

Example of a Min-heap

16

5

8

15 11

18 12

20

27

33

30

53

Operations on Heaps

• Delete the minimum value and return it. This operation is called delete-Min.

• Insert a new data value

Applications of Heaps:• A heap implements a priority queue, which is a queue that orders entities not a on first-come first-serve basis, but on a priority basis: the item of highest priority is at the head, and the item of the lowest priority is at the tail

• Another application: sorting, which will be seen later

54

Delete-Min in Min-heaps

• The minimum value in a min-heap is at the root!• To delete the min, you can’t just remove the data

value of the root, because every node must hold a key

• Instead, take the last node from the heap, move its key to the root, and delete that last node

• But now, the tree is no longer a heap (still almost complete, but the root key value may no longer be ≤ the keys of its children

55

Illustration of First Stage of delete-min

16

5

8

15 11

18 12

20

27

33

30

16

8

15 11

18 12

20

27

33

30

16

8

15 11

18

1220

27

33

30

16

8

15 11

18

1220

27

33

30

56

Restore Heap

• To bring the structure back to its “heapness”, we restore the heap

• Swap the new root key with the smaller child.

• Now the potential bug is at the one level down. If it is not already ≤ the keys of its children, swap it with its smaller child

• Keep repeating the last step until the “bug” key becomes ≤ its children, or the it becomes a leaf

57

Illustration of Restore-Heap

16

8

15 11

18

1220

27

33

30

16

12

15 11

18

820

27

33

30

16

11

15 12

18

820

27

33

30

Now it is a correct heap

58

Time complexity of insertand delete-min

• Both operations takes time proportional to the height of the tree– When restoring the heap, the bug moves from level to

level until, in the worst case, it becomes a leaf (in delete-min) or the root (in insert)

– Each move to a new level takes constant time– Therefore, the time is proportional to the number of

levels, which is the height of the tree.

• But the height is O(log n)• Therefore, both insert and delete-min take O(log

n) time, which is very fast.

59

Inserting into a min-heap

• Suppose you want to insert a new value x into the heap

• Create a new node at the “end” of the heap (or put x at the end of the array)

• If x is >= its parent, done• Otherwise, we have to restore the heap:

– Repeatedly swap x with its parent until either x reaches the root of x becomes >= its parent

60

The Min-heap Class in C++

class Minheap{ //the heap is implemented with a dynamic array public: typedef int datatype; Minheap(int cap = 10){capacity=cap; length=0; ptr = new datatype[cap];}; datatype deleteMin( ); void insert(datatype x); bool isEmpty( ) {return length==0;}; int size( ) {return length;}; private: datatype *ptr; // points to the array int capacity; int length; void doubleCapacity(); //doubles the capacity when needed};

61

Code for delete-min

Minheap::datatype Minheap::deleteMin( ){ assert(length>0); datatype returnValue = ptr[0]; length--; ptr[0]=ptr[length]; // move last value to root element int i=0; while ((2*i+1<length && ptr[i]>ptr[2*i+1]) || (2*i+2<length && (ptr[i]>ptr[2*i+1] || ptr[i]>ptr[2*i+2]))){ // “bug” still > at least one child if (ptr[2*i+1] <= ptr[2*i+2]){ // left child is the smaller child datatype tmp= ptr[i]; ptr[i]=ptr[2*i+1]; ptr[2*i+1]=tmp; //swap i=2*i+1; } else{ // right child if the smaller child. Swap bug with right child. datatype tmp= ptr[i]; ptr[i]=ptr[2*i+2]; ptr[2*i+2]=tmp; // swap i=2*i+2; } } return returnValue; };

62

Code for Insert

void Minheap::insert(datatype x){ if (length==capacity) doubleCapacity(); ptr[length]=x; int i=length; length++; while (i>0 && ptr[i] < ptr[i/2]){ datatype tmp= ptr[i]; ptr[i]=ptr[(i-1)/2]; ptr[(i-1)/2]=tmp; i=(i-1)/2; }};

63

Code for doubleCapacity

void Minheap::doubleCapacity(){ capacity = 2*capacity; datatype *newptr = new datatype[capacity]; for (int i=0;i<length;i++) newptr[i]=ptr[i]; delete [] ptr; ptr = newptr;};

64

End of Lecture