CS 103 1

Trees

• A Quick Introduction to Graphs

• Definition of Trees

• Rooted Trees

• Binary Trees

• Binary Search Trees

CS 103 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

CS 103 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.

CS 103 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

CS 103 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”, …

CS 103 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.

CS 103 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

CS 103 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

CS 103 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

CS 103 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

CS 103 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

CS 103 12

Trees• A tree is a connected acyclic undirected

graph. The following are three trees:

1

2

53 11

12

10

98

7

64

CS 103 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.

CS 103 14

Example of a Rooted Tree

1

2

53 11

12

10

98

7

64

1

23

10

11

98

4 6

5

7

12Unrooted tree

Tree rooted with root 1

CS 103 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

CS 103 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

CS 103 17

Binary Trees• A tree is a binary tree if every node has at

most two children1

23

10

11

98

4 6

5

7

12

1

3

10

11

98

4 6

5

7

12

Nonbinary tree

Binary tree

CS 103 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 and

a 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

CS 103 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

CS 103 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

};

CS 103 21

Binary Tree Classclass 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;};

CS 103 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

CS 103 23

Example of a BST

6

15

8

2

3 7

11

10

14

12

20

27

22 30

CS 103 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

CS 103 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;};

CS 103 26

Insertion into a BSTInsert(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

CS 103 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

CS 103 28

Code for Insert in BSTbool 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();} } };

CS 103 29

Deletion from a BST

• Illustration in class

CS 103 30

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)

CS 103 31

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.

CS 103 32

Code for Delete in BST(4 slides)

// finds x in the tree, removes it, and returns a pointer to the containing// TreeNode. If x is not found, the function returns NULL.TreeNode * Tree::remove(datatype x){ if (isEmpty()) return NULL; TreeNode *p=rootPtr; TreeNode *parent = NULL; // parent of p char whatChild; // 'L' if p is a left child, 'R' O.W. while (p != NULL){ datatype a = p->getData(); if (a == x) break; // x found

else if(x<a) { parent = p; whatChild = 'L'; p=p->getLeft();} else {parent = p; whatChild = 'R'; p=p->getRight();} }

if (p==NULL) return NULL; // x was not found

CS 103 33

// Handle the case where p is a leaf. // Turn the appropriate pointer in its parent to NULL if (p->getLeft() == NULL && p->getRight() == NULL){

if (parent != NULL) // x is not at the root if (whatChild == 'L') parent->setLeft(NULL); else parent->setRight(NULL); else // x is at the root rootPtr=NULL; return p; }

CS 103 34

else if (p->getLeft() == NULL){ // p has only one a child -- a right child. Let the parent of p // become an immediate parent of the right child of p. if (parent != NULL) // p is not the root if (whatChild == 'L') parent->setLeft(p->getRight()); else parent->setRight(p->getRight()); else rootPtr=p->getRight(); // p is the root return p; } else if (p->getRight() == NULL){ // p has only one a child -- a left child. Let the parent of p // become an immediate parent of the left child of p. if (parent != NULL) // p is not the root if (whatChild == 'L') parent->setLeft(p->getLeft()); else parent->setRight(p->getLeft()); else rootPtr=p->getLeft(); // p is the root return p; }

CS 103 35

else { // p has two children TreeNode *returnNode= new TreeNode(*p); // replicates p TreeNode * leftChild = p->getLeft();

if (leftChild->getRight() == NULL){// leftChild has no right child p->setData(leftChild->getData()); p->setLeft(leftChild->getLeft()); delete leftChild; return returnNode; } TreeNode * maxLeft = leftChild->getRight(); TreeNode * parent2 = leftChild; while (maxLeft != NULL){parent2 = maxLeft; maxLeft = maxLeft ->getRight();}

// now maxLeft is the node to swap with p. p->setData(maxLeft->getData()); if (maxLeft->getLeft()==NULL) parent2->setRight(NULL); // maxLeft a leaf else parent2->setRight(maxLeft->getLeft()); //maxLeft not a leaf delete maxLeft; return returnNode; }

};

CS 103 36

Additional Things for YOU to Do

• Add a method to the Tree class for returning the maximum value in the BST

• Add a method to the Tree class for returning the minimum value in the BST

• Write a function that takes as input an array of type datatype, and an integer n representing the length of the array, and returns a BST Tree Object containing the elements of the input array