Trees in General. A general tree is: Either the empty trädet,, or a recursive structure: root /. \ /... \ t1... tn

Transcription

1 Trees in General Trees in General A general tree is: Either the empty trädet,, or a recursive structure: root /. \ /... \ t1... tn where t1,..., and tn in turn are trees and are named subtrees, whose root nodes is called sons or daugthers to this root node. The root node in turn is named father or mother to the subtrees root nodes. Trees 1

2 Name Conventions Trees in General In order to describe relationships between nodes we usually use son, father, grandfather, ancestor, siblings, cousins,... (alt daughter, mother, grandmother,...) A leaf is a node with only empty subtrees (or no subtrees). All other nodes are internal nodes. The depth or the height of a tree is either: the number of nodes in the longest way from the root to a leaf, or the number of edges of the longest way. The complexity is usually defined by O(f(n)), where n is the number of nodes, or somtimes O( f(h)) where h is the height or depth of the tree. Trees 2

3 Binary Trees Binary Trees A binary tree is either the empty tree,, or it is a node, named the root of the tree, consisting of som value, the (root value), and two subtrees, named left and right subtree, respectively, which in turn are binary trees. Trees 3

4 Generality of Binary Trees Binary Trees All trees can be transformed to a binary tree. The algorithm is: Let the leftmost son be the root of the left subtree in the binary tree and let all siblings to the leftmost son be a rightmost chain of roots of subtrees. e.g.: A A / \ / / \ becomes: B B C D / E C E F G F D \ G Trees 4

5 Exemple: Expression as a tree Binary trees Also referred as a syntax tree, where all the operands are leafs and all the operators are internal nods. E.g. the expression (2 + 9 ) ( 1 3 ) become: * Observe that there is no need of parantheses or priority rules, why it is simple to compute the value by recursion: compute( op ) = compute( LST ) op compute( RST ) LST RST Trees 5

6 Traversing binary trees Binary Trees Two main forms: breath first or depth first. In breath first you take the nodes level by level. By tradition we always choose the left subtree before the right subtree. At depth first this gives three posibilities in which order the nodes are treated: preorder: the root node, the nodes in left subtree, the nodes in right subtree inorder: the nodes in left subtree, the root node, the nodes in right subtree postorder: the nodes in left subtree, the nodes in right subtree, the root node Trees 6

7 Euler s Tour Binary Trees A more general scheme of traversing is the Euler s tour, where you visit the node 3 times when you follow the contour of the tree. As a general scheme you have 3 methods: visitleft(value), visitdown(value) and visitright(value) and then you put them together in the recursive traversal method: public void eulerstour( t ) { if ( t!= emptytree ) { visitleft(t.rootvalue); // preorder eulerstour( t.teft ); visitdown(t.rootvalue); // inorder eulerstour( t.right ); visitright(t.rootvalue); // postorder } } // traverse Trees 7

8 Binary Search Trees Binary Search Trees The most common use of binary trees are binary search trees: A binary search tree is a binary tree, where all the values in the left subtree is smaller than the value in the root. All values in the right subtree bigger than or equal to the value in the root. Left and right subtrees are in turn binary search trees. The most important operations on a binary search tree are: Decide if the tree is empty. Given an element, search for an equally big element in the tree. Given an element, add the element into the tree. Given an element, take out the first equally big element from the tree. (Or all equally big elements.) Since a binary tree is a recursive structure, recursion is often used to implement these operations. (some handwaving on the board) Trees 8

9 Drawbacks with plain Binary Search Trees Binary Search Tree The trees can bee very skew, which means that the 3 last operations in worst case can be of O( n ), where n is the number of nodes. This is the same as for lists! In order to decrease the complexity, balanced trees is used, and then the complexity of the operations become O( 2 log n ) Trees 9

10 Balanced trees Binary trees 1. node balanced: The difference between the number of nodes in left and right subtree, respectivly, is at most height balanced: The difference between the heights (depths) between left and right subtree, respectivly, is at most level balanced: All levels are full, except the lowermost level which are filled from left to right. Observe that the height of all these trees is of O( 2 log n ), where n is the number of nodes in the tree. Trees 10

11 Balanced Search Trees Binary trees There are a lot of balanced search trees, some examples: AVL trees Splay trees Red-black trees, based on multinary B-trees. Trees 11

12 AVL tree AVL tree AVL, invented by Adelson-Velski and Landis, describes how to balance binary search trees in such a way that all operations is of O( 2 log n ). The balancing when adding or removing nodes make sure that the tree always is height balanced. This is performed by adding height information into all nodes. The actual balancing is of O( 1 ). On the other hand, to decide where the balancing shall be done is of O( 2 log n ). There are four kinds of balancing, rotateleft, rotateright, doublerotateleft and doublerotateright. (see course literature). Let us look at rotateleft. rotateleft is read: one step to the left (may be from in some books). (Remaining only on whiteboard or in the book) Trees 12

13 Number of nodes in an AVL tree AVL tree The maximum number of nodes in a binary tree is 2 h 1. The minimum number of a tree with height h is easily expressed by the recursive function: minn od(0) = 0 minn od(1) = 1 minnod(h) = minnod(h 1) + minnod(h 2) + 1 This function is exponental in respect of h demonstrated by: 2 h 2 minnod(h) 2 h h = 1,2,... In our complexity calculations we can therefore use: n O( 2 h ) and h O( 2 log n ), where n is the number of nodes and h is the height of an AVL-träd. Trees 13

14 Minimal AVL tree AVL tree Create a minimal AVL tree of height 5. (With minimal we understand: as few elements as possible of given height.) minnod(5) is 12. We create a tree of height 5 by taking a minimal tree of height 4 as left subtree and a minimal tree of height 3 as right subtree. minnod(4) är 7, why we create the tree: 8 mintree mintree Trees 14

15 Minimal AVL tree, cont. AVL tree We work on recursively with the two subtrees and it all ends up in: / / / 1 Extra exercise: Write a Java program that computes a minimal AVL tree for a given height. (I.e. in which order do you add the elements into the tree.) Trees 15

16 Splay trees Splay trees In many situations you can observe that when searching for en element it is a big probability you will soon look it up again. Therefore, lift up the search node (or the node where the search stops) to a new root of the whole tree and at the same time balance the tree on our way up to the root. We have 6 balancing operations zig, zag, zigzag, zagzig, zigzig och zagzag. Note: zig is the same thing as rotateleft zigzag is the same thing as doublerotateleft zag is the same thing as rotateright zagzig is the same thing as doublerotateright Trees 16

17 red-black trees red-black trees A red black tree is a binary search tree where we decorated each node with a colour and which satisfies the following rules: 1. Each node must be red or black. 2. The rote is always black. 3. If a node is red, its children must be black. 4. Each way down from the root to a leaf must have the same number of black nodes. Trees 17

18 red-black trees Algorithm for insertion in a red-black tree, according to top-down with flip As usual on insertion of a new element, we start in the root search down the tree until we find a free place. On insertion in a red-black tree we do that by following the rules: 1. On the way down we use the flip rule: if a node have two red sons, we change the colours for the 3 nodes, i.e. black red ==> red red black black if the now reds parent is red the tree is adjusted according to the rules 2 or 3 down. Trees 18

19 red-black trees Algorithm for insertion, cont. 2. If the now red node is left left of its grandfather (or mirrorwise right right) we make a rotateright operation (rotateleft mirrorwise) black G / black P red P ==> / red x red G red x 3. If the now red node is right left of its grandfather (left right) we make a doublerotateright (doublerotate- Left) operation black G / black x red P ==> \ red P red G red x Trees 19

20 red-black trees Algoritm för insättning, fortsättning 4. When the proper place where to put the new element, we put it in with the colour red. If the father to the new node is red we adjust the tree according to the rules 2 and 3 above. 5. At last, if the root of the whole tree has gone red during the insertion, we let it switch back to black (according to the definition of a red-black tree). Trees 20

21 Implementation of Binary Trees Binary Trees In Java we only have two forms of concrete datastructures to implements compound structurer: either arrays or defining a node class and link the objekts of that class together using pointers. The last one is the most common one and the fields in the class for nodes of binary trees are: [ root value (or pointer to root value), ] pointer to left subtree, pointer to right subtree, pointer to father node, Trees 21

22 Implementation of binary trees Binära träd It is possible to implement trees in arrays also, which is often referred to as a heap and is level balanced. When we have search trees, they are organised by the elements (i.e. objects in Java) size decided by the method compareto in Java Trees 22

23 Heap in General Heap A heap is a binary level balanced tree concrete implemented in an array. The root of the whole tree is under index 1. Then the rules are: The node under index i has its left subtrees root under index 2 i and its right subtrees root under index 2 i + 1 Therfore, the father of a node under index i is under index i div 2, where div is integer dividing. Heap-property: The root in each subtree contains the smallest node value in the whole subtree. Trees 23

24 Heap exemple Heap The tree: is implemented by: / Trees 24

25 Insertion of 2 gives: Heap Trees 25

26 Removing the smallest element gives: Heap / 11 (1) Trees 26

27 The Method add in Java Heap public void add( E elem ) { int hole = ++size; if ( hole == qe.length ) { E [] temp = (E []) new Object[ 3 * qe.length / ]; System.arraycopy( qe, 0, temp, 0, qe.length ); qe = temp; } while ( hole > 1 && elem.compareto( qe[hole >> 1] ) < 0 ) { qe[hole] = qe[hole >> 1]; hole >>= 1; } qe[hole] = elem; } // add Trees 27