1 A node in a tree. Trees. Datatypes ISC

Transcription

1 Datatypes ISC A node in a tree /*C*/ typedef struct _node { struct _node *left; struct _node *right; struct _node *parent; float value; node; # # Python example class Node: Node class: this is a container for content that is saved at nodes in a tree def init (self): basic node init self.value = -1 self.left = -1 self.right = -1 self.ancestor = -1 Trees Trees terminology: leaf node, terminal node, tips, node, internal node, edges, branches, subtree, height, depth, drawing trees Example of a simply tree using species. 1 Peter Beerli; January 6, 2011

2 Datatypes ISC Example of a binary search tree: Binary search tree property: Let x be a node in a binary search tree. If y is a node in the left subtree of x, then key[y] key[x]. If y is a node in the right subtree of x, then key[x] key[y]. Examples if binary search trees with different depth for the values 1, 4, 5, 10, 16, 17, 21. Pay attention to the different height of the trees. Traversing a tree: inorder_tree_walk(x) { then inorder_tree_walk(left[x]) print key[x] preorder_tree_walk(x) { then print key[x] inorder_tree_walk(left[x]) postorder_tree_walk(x) { then inorder_tree_walk(left[x]) print key[x] 2 Peter Beerli; January 6, 2011

3 Datatypes ISC Searching elements in a tree tree_search(x, k) { if x == NIL or k==key[x] then return x if k < key[x] then tree_search(left[x],k) else tree_search(right[x],k) This can also be expressed non-recursively: non_recurse_tree_search(x, k) { while x!= NIL and k!=key[x] do if k < key[x] then x = left[x] return x else x = right[x] finding minimum, maximum is easy because of the left (smaller) and right (bigger) ordering inserting a node into the tree (aka building trees) tree_insert(tree, z) { y = NIL x = root[tree] while x!= NIL do y = x if key[z] < key[x] then x = left[x] else x = right[x] parent[z] = y if y == NIL then root[tree] = z else if key[z] < key[y] then left[y] = z else right[y]=z Deletion is more tricky [Look it up] Randomly built binary search trees: consider the input order of data for a binary search tree, it plays a tremendous role how deep such a tree is. Unrooted trees: methods? balancing? 3 Peter Beerli; January 6, 2011

4 Datatypes ISC Red-Black trees [ tree] A red-black tree is a special type of binary tree, used in computer science to organize pieces of comparable data, such as text fragments or numbers. The leaf nodes of red-black trees do not contain data. These leaves need not be explicit in computer memory a null child pointer can encode the fact that this child is a leaf but it simplifies some algorithms for operating on red-black trees if the leaves really are explicit nodes. To save memory, sometimes a single sentinel node performs the role of all leaf nodes; all references from internal nodes to leaf nodes then point to the sentinel node. Red-black trees, like all binary search trees, allow efficient in-order traversal in the fashion, Left-Root-Right, of their elements. The search-time results from the traversal from root to leaf, and therefore a balanced tree, having the least possible tree height, results in O(log n) search time. A node is either red or black. The root is black. (This rule is sometimes omitted from other definitions. Since the root can always be changed from red to black but not necessarily vice-versa this rule has little effect on analysis.) All leaves are black. Both children of every red node are black. Every simple path from a given node to any of its descendant leaves contains the same number of black nodes. B-trees [Bayer, R.; McCreight, E. (1972), Organization and Maintenance of Large Ordered Indexes, Acta Informatica 1 (3): ] The B-tree is a generalization of a binary search tree in that a node can have more than two children. (Comer, p. 123) Unlike self-balancing binary search trees, the B-tree is optimized for systems that read and write large blocks of data. It is commonly used in databases and filesystems. For example a B-tree of order 2 (following Bayer & McCreight) or 5 (following Knuth). 4 Peter Beerli; January 6, 2011

5 Datatypes ISC B-trees have substantial advantages over alternative implementations when node access times far exceed access times within nodes. This usually occurs when the nodes are in secondary storage such as disk drives. By maximizing the number of child nodes within each internal node, the height of the tree decreases and the number of expensive node accesses is reduced. In addition, rebalancing the tree occurs less often. The maximum number of child nodes depends on the information that must be stored for each child node and the size of a full disk block or an analogous size in secondary storage. While 2-3 B-trees are easier to explain, practical B-trees using secondary storage want a large number of child nodes to improve performance. Quad-trees, adjacency lists see the file: quadtrees.pdf 5 Peter Beerli; January 6, 2011