Trees

Trees: Basic terminology[1]

   

Hierarchical data structure Each position in the tree is called a node The top of the tree is called the root The nodes immediately below a node are called its children; nodes with no children are called leaves (or terminal nodes), or terminal nodes, and the node above a given node is its parent (or father) A node x is ancestor of node y if x is father of y or father of some ancestor of y. y is called descendent of x. Ancestor of a node is its parent, grand parent or grand-grand parent or so on.

Trees: Basic terminology[2]

Nodes with the same parent are siblings  A node plus the collection of nodes beneath it is called a subtree  The number of nodes in the longest path from the root to a leaf is the depth (or height) of the tree


is the depth 2 or 3? depends on the author

Root Node A Node C Node D Node E Node B Node F Node G

Node H

Node I

Node J

Node K Node L

Nodes C, H, and I form a subtree Nodes H and I are siblings C is Hs parent, H and I are children of C What is the depth of this tree?

Binary Trees
A commonly used type of tree is a binary tree  Each node has at most two children  The tree is a conceptual structure  The data can be stored either in a dynamic linked tree structure, or in contiguous memory cells (array) according to a set pattern; in other words, implementation can be pointer-based or array-based


Binary trees
  

A tree is called strictly binary tree if every non leaf node has exactly two children. A strictly binary tree having n leaves always contain 2n-1 nodes Text book definition of depth of a tree
Depth of binary tree is maximum level of any leaf in the tree. Root of tree is at level 0, and level of any other node in the tree is one more than the level of its father

Binary Trees
  

A complete binary tree of level d is the strictly binary tree all of whose leaves are at level d A complete binary tree of level d has 2l nodes at each level l where 0<=l<=d Total number of nodes (tn) in a complete binary tree of depth d will be:
d

tn ! 2  2  2      2

2 j ! 2 d 1  1
j !0

For a binary tree of height h there are O(2h) nodes

Binary Trees


For a complete binary tree if number of nodes (tn) are known, then we may find depth of the binary tree tn ! 2 d 1  1

2 d 1 ! tn  1 d  1 ! log 2 (tn  1) d ! log 2 (tn  1) - 1

A binary tree with nodes n has height O(log2n)

Binary Trees Storage

Linked List based implementation  Array based implementation


Binary Tree: as a linked structure



Each node in the tree consists of:

The data, or value contained in the element A left child pointer (pointer to first child) A right child pointer (pointer to second child)

Binary Tree: as a linked structure



A root pointer points to the root node

Follow pointers to find every other element in the tree

Add and remove nodes by manipulating pointers  Leaf nodes have child pointers set to null


class CBinTree { struct Node { int value; Node *LeftChild,*RightChild; }*Root; /***Operations*********/ /************************/ };

ROOT

Binary Tree: contiguous storage

 

   

Value in root node stored first, followed by left child, then right child Each successive level in the tree stored left to right; unused nodes in tree represented by a bit pattern to indicate nothing stored there Children of any given node n is stored in cells 2n and 2n + 1 (If array index starts at 1) Can calculate position for any given node Storage allocated as for full tree, even if many nodes empty For a tree of depth h we need array of 2h+1-1 cells

Binary Trees
Full binary tree of height (depth) h: all nodes at a height less than h have exactly two children  Balanced binary tree: for each node, the difference in depth of the right and left subtrees is no more than one  Completely balanced tree: left and right subtrees of every node have the same height


Full Binary Tree

A very sparse, unbalanced tree

Primitive Operations
       

Left(node): Gives index/pointer of left child Right(node): Gives index/pointer of right child Parent(node): Returns index/pointer of parent Brother(node): Returns index/pointer of brother Root: Gives index/pointer of root node Info(Node): Data/Info stored at node IsLeft(node): Is node left child? Yes/No IsRight(node): Is node right child? Yes/No

Common Operations
Tree traversal  Node addition  Node deletion  Destroy


Traversal of Binary Trees

Pass through all nodes of tree  Inorder (symmetric traversal)  Preorder (depth first traversal)  Postorder


Trees Traversal


Inorder
(Left) Root (Right)

Root

Preorder
Root (Left) (Right)

Left

Right

Postorder
(Left) (Right) Root

Inorder Traversal
+

Left Root Right manner

* +

Left + Right  [Left*Right]+[Left+Right]  (A*B)+[(Left*Right)+E)  (A*B)+[(C*D)+E]



(A*B)+(C*D+E)

Preorder Traversal
+

Root Left Right manner  + Left Right  + [*Left Right] [+Left Right]  +(*AB) [+ *Left Right E]  +*AB + *C D E

Postorder Traversal
+

Left Right Root manner

* +

Left Right +  [Left Right *] [Left Right+] +  (AB*) [Left Right * E + ]+  (AB*) [C D * E + ]+  AB* C D * E + +


Binary Search Tree

 

Elements are sorted: For any node n in a binary search tree:

The value at n is greater than the values of any of the nodes in its left subtree The value at n is less than the values of any of the nodes in its right subtree Its left and right subtrees are binary search trees

Need to define greater than and less than for the specific data