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}
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. 1 3 5 4
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}
Mary
Helen
Joe
John
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}
Mary
Helen
Joe
John
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
Connected
Disconnected
CS 103

11. Graph Cyclicity
An undirected graph is cyclic if it has at least one cycle. Otherwise, it is acyclic
Disconnected and cyclic
Connected and cyclic
Disconnected and acyclic
Connected and acyclic
CS 103

12. Trees
A tree is a connected acyclic undirected graph. The following are three trees: 8 9 2 10 1 7 5 12 3 11 4 6
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 Tree1 2 3 10 11 9 8 4 6 5 7 12 8 9 2 10 1 7 5 12 3 11 4 6
Unrooted 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 2 3 10 11 9 8 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 2 3 10 11 9 8 4 6 5 7 12
CS 103

17. Binary Trees
A tree is a binary tree if every node has at most two children 1 2 3 10 11 9 8 4 6 5 7 12 1 3 7 5 8 9 10 4 6 11 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 child
only, a right child only,
or no children
The tree made up of a left
child (of a node x) and all its
descendents is called the left subtree of x
Right subtrees are defined similarly 1 3 11 9 8 4 6 5 7 12 10
CS 103

19. Graphical View Binary-tree Nodes
Graphically, a TreeNode is:
A binary-tree node
consists of 3 parts:
Data
Pointer to left child
Pointer to right child
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.
data
5.8 2
label
CS 103

20. A Binary-tree Node Class
class 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 apps
TreeNode *left; // the pointer to left child
TreeNode *right; // the pointer to right child };
CS 103

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; };
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: Compare b with the root;6 15 8 2 3 7 11 10 14 12 20 27 22 30
To search for a number b:
Compare b with the root;
If b=root, return
If b<root, go left
If b>root, go right
Repeat step 1, comparing b with the new node we are at.
Repeat until either the node is found or we reach a non-existing node
Try it with b=12, and also with b=17
CS 103

25. Code for Search in BST
// returns a pointer to the TreeNode that contains x,
// if one is found. Otherwise, it returns NULL
TreeNode * 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 BST Insert(datatype b, Tree T):
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.
Create a new node, and assign its address to the appropriate pointer field in x
Assign b to the data field of the new node
CS 103

27. Illustration of Insert6 15 8 2 3 7 11 10 14 12 20 27 22 30 15 8 20 2 11 27 6 30 10 12 22 3 7 14 25
Before inserting 25
After inserting 25
CS 103

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
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)
Search for b in tree T. If not found, return.
Call x the first node found to contain b
If x is a leaf, remove x and set the appropriate pointer in the parent of x to NULL
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 (whatChild == 'L') parent->setLeft(p->getLeft());
else parent->setRight(p->getLeft());
else rootPtr=p->getLeft(); // p is the root
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; };
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
CS 103