Binary Trees Data Structure

Special types of binary trees

- Full: Every node contains 0 or 2 children. - Complete: If all levels (except last) are completely full and all nodes in last level are as far left as possible. - Perfect: If all internal nodes have 2 children and all leaf are at the same level.

BST remove algorithm: Remove an internal node w/two children

1. Locates X's successor (leftmost child of X's right subtree) [Hardest Case] 2. Copies the successor to X 3. Remove successor from the right subtree.

Parent

A node with a child is said to be that child's parent. → Node's ancestors include the node's parent, the parent's parent, etc., up to the tree's root.

Internal node

A node with at least one child.

Leaf

A tree node with no children.

Tree level

All nodes with the same depth

Successors and predecessors

BST defines an ordering among nodes, from smallest to largest

BST search algorithm

Checks current node (tree's root), returning that node as a match - Returns node immediately; no add search needed Else: Assign current node to → left (if key is less) → right (if key is greater) If child is null: Returns null (upon existing loop)

Binary Tree

Each node has up to two children/successors → Left child and Right child

Special types of binary trees: Full

Every node contains 0 or 2 children.

BST remove algorithm: Remove internal node w/ single child

If X is not root/no parent: - Parent's of X is assigned to X's single child. Else, if X was root/parent - Root pointer assigned w/X's single child.

Special types of binary trees: Perfect

If all internal nodes have 2 children and all leaf are at the same level.

Special types of binary trees: Complete

If all levels (except last) are completely full and all nodes in last level are as far left as possible.

BST Insert Algorithm: Search for insert location

If child not null → current node to child and continues searching

BST Insert Algorithm: Insert as right child

If new node's key is greater than the current node, and current node's right child is null

BST Insert Algorithm

Inserts new node in proper location obeying BST ordering property - Compares the new node with the current node (initially the root) → Insert as left or right child

Tree height

Largest depth of any node → Tree with just one node has height 0. Minimize height → by keeping all levels fulls Calculate (floor(log2N))

Edge

Link from a node to a child

Binary Tree: Usefulness

May require fewer comparisons → enables fast searching N-node binary tree's height may be as small as O(logN), yielding extremely fast searches Ex: A 10,000 node list may require 10,000 comparisons, but a 10,000 node BST may require only 14 comparisons.

Searching: To search node

Means to find node w/desired key, if such a node exists - BST may yield faster searches than a list.

BST Insert Algorithm: Insert as left child

New node's key is < current node, and the current node's left child is null

BST remove algorithm: Remove a leaf node

Node is assigned w/null If X is not root/no parent: - Parent's left or right child assigned w/null. Else, if X was root/parent: Root pointer assigned w/null → BST is now empty.

Successor

Node that comes after in the BST ordering Node w/right subtree: → Successor: that right subtree's leftmost child (left w/o other left) Node w/o right subtree: → Successor: first ancestor having this node in a left subtree

Depth

Number of edges on the path from the root to the node → Root node thus has depth 0.

Binary Search Tree (BST)

Ordering property that any node's - Left subtree keys ≤ the node's key - Right subtree's keys ≥ the node's key → enables fast searching

BST Remove Algorithm

Removes the first-found matching node, restructuring the tree to preserve the BST ordering property 1. Search for matching node (like search alg) 2. If found (call this node X), performs one of the following sub-algorithms • Remove a leaf node: • Remove internal node w/single child • Remove an internal node w/ two children Removing a node from N-node nearly-fullBST computational complexity: O(logN)

Pseudocode: Binary Search Tree (BST) (Searching

Starts by visiting the root node (first currentNode) → If a child to be visited doesn't exist, the desired node does not exist

Root

The one tree node with no parent → "top" node

BST Insert Algorithm Complexity

Traverses the tree from the root to a leaf node to find the insertion location. One node is visited per level BST w/N nodes has - At Least log2N levels: O(logN) - At Most N levels: O(N) Space complexity: O(1) → bc only single pointer used to traverse tree to find the insertion location.

BST remove algorithm complexity

Traverses tree from root to find node to remove. - Worst case scenario: tree traversed twice from root to a leaf Best case: O(logN) Worse case: O(N) Space complexity: O(1)

BST inorder traversal

Tree traversal algorithm: visits all nodes in the tree once → operation on each o From smallest to largest→ useful to print nodes sorted o root → left subtree → current node → right subtree. From largest to smallest → use: right/ current/ left sequence

BST search Runtime

Worst case: O(H) - Full Binary Height = log2N (round down) → H+1 is the tree height ▪ N-node binary tree's height may be as small as O(log N) → extremely fast

Predecessor

node that comes before in the BST ordering.

Searching a nearly-full BST with N nodes requires

only O(logN) comparisons.

In a list, each node has up to one successor, binary tree has up to

two successors