1. 1 CSE 1342 Programming Concepts Trees

2. 2 Basic Terminology Trees are made up of nodes and edges. A tree has a single node known as a root. –The root is typically drawn as the highest node in the tree Every node other than the root is connected to some other node called the parent. P C parent child edgenode root

3. 3 Basic Terminology A node can have no more that one parent A node can have zero or more children Parents are typically drawn above their children A tree is connected in that if we start at any node other than the root and move to its parent and so on, we will eventually arrive at the root of the tree. P C2C1Cn...

4. 4 Paths, Ancestors and Descendants A node by itself is considered a tree. A node and all of its descendants are considered a tree. An empty tree (root pointer == NULL) is considered a tree. n1 n3n2n4 n5n6n7 root

5. 5 Paths, Ancestors, and Descendants Trees are built upon recursive definitions. Any node an all of its descendants is considered a subtree. n1 n3n2n4 n5n6n7 root Sub-tree

6. 6 Paths, Ancestors and Descendants Nodes with no descendants are leaf nodes. Node n1 (the root) is an ancestor of all remaining nodes in the tree. n1 n3n2n4 n5n6n7 Leaf nodes

7. 7 Paths, Ancestors and Descendants Nodes n2.. n7 are all descendants of n1. The path from n4 to n7 has a length of 1. –This is equal to the number of nodes on the path - 1. n1 n3n2n4 n5n6n7 Descendants of n1

8. 8 Paths, Ancestors and Descendants The height of a node is the length of the longest path from the node to a leaf. –The height of the tree is 2, the height of the root. –The height of n1 is 2. –The height of n4 is 1 –The height on n6 is 0. n1 n3n2n4 n5n6n7 Height of tree is 2

9. 9 Paths, Ancestors and Descendants The depth of a node is the length of the longest path from the root to the node. –The depth of n5 is 2. –The height of n5 is 0. –The depth of n3 is 1. –The height of n3 is 0. n1 n3n2n4 n5n6n7 The depth of n5 is 2

10. 10 Binary Trees A binary tree node can have at most two children, a left child node and a right child node. Typical node definition for a binary tree: struct Node { int data; Node *leftChild, *rightChild; }; n1 n2n3 Left childRight child

11. 11 Binary Trees struct Node { int data; Node *leftChild, *rightChild; }; The pointer fields are used to implement the edges of the tree. The data in the node may be simple or complex. –One of the data fields must serve as a key field.

12. 12 Binary Trees A general recursive scheme for traversing a binary tree is: { action 1; recursive call on left subtree action 2; recursive call on right subtree action 3; } Not all three actions are required. The right subtree can be visited before the left subtree.

13. 13 Binary Search Trees A binary search tree is a labeled binary tree in which the following properties hold at every node x in the tree: –All nodes in the left subtree of x have labels (values) less than the value of x. –All nodes in the right subtree of x have labels (values) greater than the value of x.

14. 14 Binary Search Trees Order of insertion: 9, 3, 1, 4, 7, 6, 10 results in the above tree. 9 7 310 1 4 6

15. 15 Binary Search Trees Changing the order of insertion to: 6, 4, 1, 7, 3, 9, 10 results in the above tree. 6 10 4 7 1 9 3

16. 16 Binary Search Trees The following recursive algorithm displays the contents of a binary tree in ascending order. void ascending (Node *t) { if (t != NULL) { ascending(t->leftChild); (1) cout data; ascending(t->rightChild); (2)} }

17. 17 Binary Search Trees A binary search tree must support the following operations: –Insertion of new nodes. –Deletion of existing nodes. –Verification that a node is/isn’t in the tree A data set upon which we can execute an insert, delete, and look-up is called a dictionary, no matter how the set is implemented or what it is used for.

18. 18 Search Tree Verification //This function returns a 1 (true) if x is in the tree and 0 (false) //if x is not in the tree int lookUp (elementType x, Node *t) { if (t = = NULL) return 0; else if (x = = t->element) return 1; else if (x element) return lookUp(x, t->leftChild); else // x must be > t->element return lookUp(x, t->rightChild); }

19. 19 Search Tree Insertion //This function inserts a new x into the tree Node* insert (elementType x, Node *t) { if (t = = NULL) { t = new Node; t->element = x; t->leftChild = NULL; t->rightChild = NULL; } else if (x element) (1) t->leftChild = insert(x, t->leftChild); else if (x > t->element) (2) t->rightChild = insert(x, t->rightChild); return t; }

20. 20 Search Tree Deletion There are 3 cases that must be supported with a binary search tree deletion. –Case 1: Node to be deleted (b) is a leaf 10 20 a b delete a->rightChild; a->rightChild = NULL; 10 a (before)(after)

21. 21 Search Tree Deletion –Case 2: Node to be deleted (b) has only 1 subtree tempPtr = b->rightChild; delete a->rightChild; a->rightChild = tempPtr; 30 10 20 2540 a b 30 10 2540 a (before)(after) c d e c d e

22. 22 Search Tree Deletion –Case 3: Node to be deleted (b) has 2 children Replace the node to be deleted (b) with the smallest node in the right subtree of b. 40 10 30 3550 a b(before) 37 20 15 cd efg h 40 10 35 3750 a f(after) 20 15 cd ehg

23. 23 Search Tree Deletion –Case 3: Node to be deleted (b) has 2 children 40 10 30 3550 a b(before) 37 20 15 cd efg h 40 10 35 3750 a f(after) 20 15 cd ehg Smallest node will never have a left child. Note how the right subtree of the smallest right subtree was reattached.

24. 24 Deletion Algorithm

25. 25 Height-Balanced Binary Trees Trees should be kept as short and bushy as possible. Order of insertion: 6, 4, 9, 10, 7, 5, 1 results in a height-balanced tree. This is a best case insertion scenario resulting in a search time of O(log n). 6 10 49 175

26. 26 Skewed Binary Trees Order of insertion: 1, 3, 4, 6, 7, 9, 10 results in a skewed tree. This is a worst case insertion scenario resulting in a search time of O(n). 6 10 4 9 1 7 3