4
 A set of nodes (or vertices) with a single starting point  called the root  Each node is connected by an edge to another node  A tree is a connected graph  There is a path to every node in the tree  A tree has one less edge than the number of nodes 4

5
John Edgar5 yes! NO! All the nodes are not connected NO! There is an extra edge (5 nodes and 5 edges) yes! (but not a binary tree) yes! (it’s actually the same graph as the blue one)

6
A BCD GEF NNode v is said to be a child of u, and u the parent of v if TThere is an edge between the nodes u and v, and uu is above v in the tree, TThis relationship can be generalized EE and F are descendants of A DD and A are ancestors of G BB, C and D are siblings FF and G are? 6 root edge parent of B, C, D

7
John Edgar  A leaf is a node with no children  A path is a sequence of nodes v 1 … v n  where v i is a parent of v i+1 (1  i  n)  A subtree is any node in the tree along with all of its descendants  A binary tree is a tree with at most two children per node  The children are referred to as left and right  We can also refer to left and right subtrees 7

8
John Edgar8 C A B C D GEF EFGDGA C, E, F and G are leaves path from A to D to G subtree rooted at B

9
9 A BC GDE left subtree of A H IJ F right subtree of C right child of A

10
 The height of a node v is the length of the longest path from v to a leaf  The height of the tree is the height of the root  The depth of a node v is the length of the path from v to the root  This is also referred to as the level of a node  Note that there is a slightly different formulation of the height of a tree  Where the height of a tree is said to be the number of different levels of nodes in the tree (including the root) 10

12
John Edgar  A binary tree is perfect, if  No node has only one child  And all the leaves have the same depth  A perfect binary tree of height h has  2 h+1 – 1 nodes, of which 2 h are leaves  Perfect trees are also complete 12 A BC GDE F

13
John Edgar  Each level doubles the number of nodes  Level 1 has 2 nodes (2 1 )  Level 2 has 4 nodes (2 2 ) or 2 times the number in Level 1  Therefore a tree with h levels has 2 h+1 - 1nodes  The root level has 1 node 13 12 22 31 2324 33 34 353638 01 11 21 32 37 the bottom level has 2 h nodes, that is, just over ½ the nodes are leaves the bottom level has 2 h nodes, that is, just over ½ the nodes are leaves

14
John Edgar  A binary tree is complete if  The leaves are on at most two different levels,  The second to bottom level is completely filled in and  The leaves on the bottom level are as far to the left as possible 14 A BC DE F

15
John Edgar  A binary tree is balanced if  Leaves are all about the same distance from the root  The exact specification varies  Sometimes trees are balanced by comparing the height of nodes  e.g. the height of a node’s right subtree is at most one different from the height of its left subtree  Sometimes a tree's height is compared to the number of nodes  e.g. red-black trees 15

19
John Edgar  A traversal algorithm for a binary tree visits each node in the tree  Typically, it will do something while visiting each node!  Traversal algorithms are naturally recursive  There are three traversal methods  Inorder  Preorder  Postorder 19

25
John Edgar  Consider maintaining data in some order  The data is to be frequently searched on the sort key e.g. a dictionary  Possible solutions might be:  A sorted array ▪ Access in O(logn) using binary search ▪ Insertion and deletion in linear time  An ordered linked list ▪ Access, insertion and deletion in linear time 25

26
John Edgar  The data structure should be able to perform all these operations efficiently  Create an empty dictionary  Insert  Delete  Look up  The insert, delete and look up operations should be performed in at most O(logn) time 26

27
John Edgar  A binary search tree is a binary tree with a special property  For all nodes in the tree: ▪ All nodes in a left subtree have labels less than the label of the subtree's root ▪ All nodes in a right subtree have labels greater than or equal to the label of the subtree's root  Binary search trees are fully ordered 27

31
John Edgar  Binary search trees can be implemented using a reference structure  Tree nodes contain data and two pointers to nodes 31 Node* leftChild Node* rightChild data references or pointers to Nodes data to be stored in the tree (usually an object)

32
John Edgar  To find a value in a BST search from the root node:  If the target is less than the value in the node search its left subtree  If the target is greater than the value in the node search its right subtree  Otherwise return true, (or a pointer to the data, or …)  How many comparisons?  One for each node on the path  Worst case: height of the tree + 1 32

36
John Edgar  The BST property must hold after insertion  Therefore the new node must be inserted in the correct position  This position is found by performing a search  If the search ends at the (null) left child of a node make its left child refer to the new node  If the search ends at the right child of a node make its right child refer to the new node  The cost is about the same as the cost for the search algorithm, O(height) 36

39
John Edgar  After deletion the BST property must hold  Deletion is not as straightforward as search or insertion  With insertion the strategy is to insert a new leaf  Which avoids changing the internal structure of the tree  This is not possible with deletion ▪ Since the deleted node's position is not chosen by the algorithm  There are a number of different cases that must be considered 39

40
John Edgar  The node to be deleted has no children  Remove it (assigning null to its parent’s reference)  The node to be deleted has one child  Replace the node with its subtree  The node to be deleted has two children  … 40

44
John Edgar  One of the issues with implementing a BST is the necessity to look at both children  And, just like a linked list, look ahead for insertion and deletion  And check that a node is null before accessing its member variables  Consider deleting a node with one child in more detail 44

46
John Edgar46 635479535996579197 delete 59 parent nd isLeftChild = false Now we have enough information to detach 59, after attaching its child to 54

47
John Edgar  The most difficult case is when the node to be deleted has two children  The strategy when the deleted node had one child was to replace it with its child  But when the node has two children problems arise  Which child should we replace the node with?  We could solve this by just picking one …  But what if the node we replace it with also has two children?  This will cause a problem 47

48
John Edgar48 6341107125437445359965791974732192330 delete 32 let’s say that we decide to replace it with its right child (41) But 41 has 2 children, and it also has to inherit (adopt?) the other child of its deleted parent

49
John Edgar  When a node has two children, instead of replacing it with one of its children find its predecesor  A node’s predecessor is the right most node of its left subtree  The predecessor is the node in the tree with the largest value less than the node’s value  The predecesor cannot have a right child and can therefore have at most one child  Why? 49

50
John Edgar50 6341107125437445359965791974732192330 32’s predecessor the predecessor of 32 is the right most node in its left subtree The predecessor cannot have a right child as it wouldn’t then be the right most node 30

51
John Edgar  The predecssor has some useful properties  Because of the BST property it must be the largest value less than its ancestor’s value ▪ It is to the right of all of the nodes in its ancestor’s left subtree so must be greater than them ▪ It is less than the nodes in its ancestor’s right subtree  It can have only one child  These properties make it a good candidate to replace its ancestor 51

52
John Edgar  The successor to a node is the left most child of its right subtree  It has the smallest value greater than its ancestor’s value  And cannot have a left child  The successor can also be used to replace a deleted node  Pick either! 52

62
John Edgar  Instead of deleting a BST node mark it as deleted in some way  Set the data object to null, for example  And change the insertion algorithm to look for empty nodes  And insert the new item in an empty node that is found on the way down the tree 62

63
John Edgar  An alternative to the deletion approach for nodes with 2 children is to replace the data  The data from the predecessor node is copied into the node to be deleted  And the predecessor node is then deleted ▪ Using the approach described for deleting nodes with one or no children  This avoids some of the complicated pointer assignments 63

65
John Edgar  The efficiency of BST operations depends on the height of the tree  All three operations (search, insert and delete) are O(height)  If the tree is complete the height is  log(n)   What if it isn’t complete? 65

68
John Edgar  It would be ideal if a BST was always close to complete  i.e. balanced  How do we guarantee a balanced BST?  We have to make the structure and / or the insertion and deletion algorithms more complex ▪ e.g. red – black trees. 68

69
John Edgar IIt is possible to sort an array using a binary search tree IInsert the array items into an empty tree WWrite the data from the tree back into the array using an InOrder traversal RRunning time = n*(insertion cost) + traversal IInsertion cost is O(h) TTraversal is O(n) TTotal = O(n) * O(h) + O(n), i.e. O(n * h) IIf the tree is balanced = O(n * log(n)) 69

About project

Feedback

To ensure the functioning of the site, we use cookies. We share information about your activities on the site with our partners and Google partners: social networks and companies engaged in advertising and web analytics. For more information, see the Privacy Policy and Google Privacy &amp Terms.
Your consent to our cookies if you continue to use this website.