1. Starting at 4.2 - Binary Trees
A binary tree is made up of a finite set of nodes that is either empty or consists of a node called the root together with two binary trees called the left and right subtrees which are disjoint from each other and from the root
Notation: Node, Children, Edge, Parent, Ancestor, Descendant, Path, Depth, Height, Level, Leaf Node, Internal Node, Subtree. A B C D E F G H I

2. Preorder traversal: Visit each node before visiting its children.
Traversals
Any process for visiting the nodes in some order is called a traversal.
Any traversal that lists every node in the tree exactly once is called an enumeration of the tree’s nodes.
Preorder traversal: Visit each node before visiting its children.
Postorder traversal: Visit each node after visiting its children.
Inorder traversal: Visit the left subtree, then the node, then the right subtree.
void preorder(BinNode * root) {
if (root==NULL) return;
visit(root);
preorder(root->leftchild());
preorder(root->rightchild()); }

3. Expression Trees Example of (a-b)/((x*y+3)-(6*z)) a / - - b + * 6 z *

4. Constructing an Expression Tree
Much easier with a postfix expression.
Study pages to see how to do this.
Now as we scan from left to right the postfix expression
If the item is an operand, create a one node tree and push the pointer onto a stack
Else if the item is an operator, pop the 2 operand pointers off the top of the stack, create a new node with left and right pointers to the 2 popped nodes and push the new node onto the stack

5. Binary Search Trees Left means less – right means greater. Find
If item<cur->dat then cur=cur->left
Else if item>cur->dat then cur=cur->right
Else found
Repeat while not found and cur not NULL
No need for recursion.
INSERT – find until cur is NULL then insert after previous node.

6. Find min and max The min will be all the way to the left
While cur->left != NULL, cur=cur->left
The max will be all the way to the right
While cur->right !=NULL, cur=cur->right
Insert
Like a find, but stop when you would go to a null and insert there.

7. Remove
If node to be deleted is a leaf (no children), can remove it and adjust the parent node (must keep track of previous)
If the node to be deleted has one child, remove it and have the parent point to that child.
If the node to be deleted has 2 children
Replace the data value with the smallest value in the right subtree
Delete the smallest value in the right subtree (it will have no left child, so a trivial delete.

8. Algorithm Analysis
If the tree is perfectly balanced, then the height of every leaf node is O(log2n).
Issues with best/worst/average case
Balance of the tree (usually based on building order)
Which data in the tree is being accessed.
Best tree shape – perfectly balanced
Worst tree shape – looks like a Linked List
Average case – look at all the shapes of every possible tree for every size n – O(log2n).

9. AVL Tree A binary search tree with a balance condition.
Ensures the tree has height O(log n).
For every node, its left and right subtree heights can differ at most by 1.
The tree can become imbalanced after an insertion
The only nodes involved in fixing the imbalance will be in the path of the inserted node.

10. Imbalancing A tree may become imbalanced at node n when:
An insertion into the left subtree of the left child of n
An insertion into the right subtree of the left child of n
An insertion into the left subtree of the right child of n
An insertion into the right subtree of the right child of n

11. Single Rotation Rotate right through n to fix case 1
Rotate left through n to fix case 4 k2 k1 k1 k2

12. Double Rotations
A single rotation does not fix case 2 k2 k1 k1 k2

13. Double rotations Must look at more stuff
Similar for inserting left of right subtree k3 k1 k2 k1 k2 k3

14. General Trees
A tree T is either empty or has a root node. This root node has pointers to some number of subtrees.
Each node can have a different number of pointers to its child trees.

15. General Tree Example Root R Ancestors of V P V S1 S2 C1 C2
Siblings of V
Children of V
Subtree rooted at V

16. Implementations of General Trees
Left Child/Right Sibling - Each node has a pointer to his leftmost child and a pointer to his right sibling (can also have a parent pointer).

17. 2-3 Tree Insertion Start with Add 14, 55 18 33 48 12 23 30 45 47 50 5210 15
20 21 24 31
18 33
48 52 12
23 30
45 47 50 55 10
14 15
20 21 24 31

18. Tree Splitting
When an addition overfills a node (gives it 3 values), then the node needs to split.
Create 2 nodes - one with the left value, one with the right value and send the middle value to the parent node to insert there.
This insertion in the parent may cause it to split. The process is then repeated.
Can minimize splitting by shifting values among sibling nodes.

19. B-Trees The B-tree is an extension of the 2-3 tree
The B-tree is THE standard file organization for applications requiring insertion, deletion and key range searches.
B-trees are always balanced.
B-trees keep related records on a disk page, which takes advantage of locality of reference.
B-trees guarantee that every node in the tree will be full at least to a certain minimum percentage. This improves space efficiency while reducing the typical number of disk fetches necessary during a search or update operation.

20. The root is either a leaf or has at least 2 children.
B-Tree Properties
A B-tree of order m has the following properties.
The root is either a leaf or has at least 2 children.
Each node, except for the root and leaves, has between m/2 and m children.
All leaves are at the same level in the tree, so the tree is always height balanced.
A B-tree node is usually selected to match the size of a disk block.
A B-tree node could have hundreds of children.

21. B-Tree Search
Search in a B-tree is a generalization of search in a 2-3 tree.
Perform a binary search on the keys in the current node. If the search key is found, then return the record. If the current node is a leaf node and the key is not found, then report an unsuccessful search.
Otherwise, follow the proper branch and repeat the process.

22. B+ Trees
Internal nodes of the B+ tree do not store records, only key values to guide the search.
Leaf nodes store records or pointers to to the records.
A leaf node has a pointer to the next sibling node. This allows for sequential processing.
An internal node with 3 keys has 4 pointers. The 3 keys are the smallest values in the last 3 nodes pointed to by the 4 pointers. The first pointer points to nodes with values less than the first key.