Trees

Trees, Binary trees, Multi-way trees

Nathan Tenney

WSU Tri-Cities

Trees

• For grouping data, we have discussed 2 basic structures
  • Arrays
  • Linked lists
• Linked lists are more flexible than arrays, but still suffer from a linear approach
• Stacks and queues added some level of hierarchy, but are limited to one dimension

Trees

• A tree is a data structure with nodes and arcs (or edges).
• Typical representation is one with a ROOT node on the top and LEAF nodes on the bottom
  • Root nodes have no parents
  • Leaf nodes have no children

Recursive Definition

• Trees can be defined recursively as follows:
  1. Empty structure is an empty tree
  2. if $t_1...t_k$ are disjointed tree, then the structure whose root has as its children the roots of $t_1...t_k$ is also a tree
  3. Only structures generated by 1 and 2 are trees

• No restriction is placed on the number of children a node can have

Trees

• A path is a unique series of arcs that links one node to another
  • There can be only one
• The length of the path is the number of arcs it contains
• The level or depth of a node is the $length + 1$ of the path from the root
• the height of a tree is maximum level of all the nodes in the tree

Tree Trivia

• An empty tree is height 0 by definition
• A single node tree is height 1
• The level of a node is between 1 and the maximum height of a tree that resembles a linked list

Tree Applications

• Unix/Linux file system
• Hierarchical for flexibility
• Databases

Binary Trees

• Limited to at most 2 children per node
• In all binary trees, there are at most $2^{i-1}$ nodes at level i
• In a binary tree of height i, there are at most $2^i - 1$ nodes in the tree

Full vs. Complete Trees

• A full binary tree is one in which:
  • All non-terminating nodes have their full complement of chlidren
  • all leaf nodes are on the same level
  • Also known as a perfect binary tree
  • Has $2^{i-1}$ nodes for a tree of height $i$

Full vs. Complete Trees

• A complete binary tree of height h:
  1. All nodes at level $h - 2$ and above have 2 children each.
  2. When a node at level $h-1$ has children, all nodes to its left at the same level have two children each.
  3. When a node at level $h-1$ has one child, it is a left child.

Complete Binary Tree

Tree Representations

Expression Trees

Binary Search Tree

• Foreach node n of the tree, all nodes in the left subtree have a value less than n, and all nodes in the right subtree have a value greater than n
• Storing multiple nodes of equal value is avoided and usually treated as an error

Insertion

• Inserting into a tree is easy
• Search for a node with a dead end and insert at that point

Deleting a Node

• This can be more tricky
• Case 1 Node is a leaf
  • Parents pointer is set to null
  • Node space is free'd
• Node has 1 child
  • Parent node takes current nodes child as its child

Deleting a Node

• Node has 2 children
  • No simple operation is available
• Delete by merging
  • Every key of the right subtree is greater than every key in the left subtree
  • Find in the left subtree the rightmost node.
  • Make the right subtree of the current node the right child of the node found in the previous step

Deleting a Node

• Delete by Merge may have a significant impact on tree balance
• Delete by Copying (Thomas Hibbard and Donald Knuth)
  • Copy the nodes predecessor into the current node and delete the node that had held the predecessor
  • Deleting that node is one of the two easy cases (Node is empty or node has one child)

Delete Example

Tree Traversals

• Visit each node exactly one time
• There are as many traversal permutations as there are nodes
• in general, we look at 3 differjent types of traversal
  • Preorder - Visit root before visiting subtrees
  • Inorder - Visit root in between visiting subtrees
  • Postorder - Visit root after visiting subtrees

Tree Traversals

• Easily done using recursion
  • Main difference between recursive definitions is when the visit function is called
• Is recursion the best way?
  • Iterative methods can be done at the expense of readability and simplicity
  • Preorder traversal would require the use of a stack (3 additional function calls per iteration)
  • Not easy to take the code from one iterative implementation and convert it to another traversal method

Balancing Trees

• Why balance binary search trees?
• Given a tree with 10,000 nodes
  • A perfectly balanced tree would be height 14
    • How many tests woud need to be performed?
  • For an unbalanced tree, up to 10,000 nodes would need to be checked.

Array Balancing Method

Array Balancing Method

• Potential problems
  • Items need to be stored in an array
• Can we adapt this solution to balancing an existing tree?

DSW Method

• Array balancing method requires additional storage.
• We may want a method that can be done "in line"
• DSW algorithm works by manipulating the existing tree

Right Rotation

rotateRight( Gr, Par, Ch){
    if(Par != root)
        Gr becomes parent of Ch
    right subtree of Ch becomes left subtree of Par
    Ch acquires Par as its right subtree
}

Left Rotation

rotateLeft( Gr, Par, Ch){
    if(Par != root)
        Gr becomes parent of Ch
    left subtree of Ch becomes right subtree of Par
    Ch acquires Par as its left subtree
}

DSW Method

• Recursively use right rotation to create a "backbone" structure
• Recursively rebuild the tree using left rotation
• createPerfectTree(n)
  • $m = 2^{\lfloor \log\left(n+1\right)\rfloor}-1$
  • make $n-m$ rotations starting from the top of the backbone
  • while($m \gt 1$)
    • $m = m / 2$
    • make m rotations starting from the top of the backbone

DSW Method

Balancing Issues

• Both algorithms produce perfecly balanced trees
• Both algorithms are "balance on demand" algorithms
• Neither is feasable if we want to balance the tree as each item is inserted

Binary Heap

• A complete binary tree
• Every node has a key more extreme (greater or less) than or equal to the key of its parent

Binary Heap

• Insertion always occurs at the leaf level
  • Insertion can cause the tree to violate the heap property
  • If a violation occurs, the node is swapped with its parent until the tree is a heap again
• Deletion always occurs at the root
  • Delete by copy with the right-most node at level h
  • Re-organize the tree to make it a heap again
    • New root is moved to the leaf level by swapping with the most extreme child
• What might this structure be useful for