AVL Tree

Keeping BSTs balanced – guarantees search, insert, and delete times by performing rotations to rebalance

• Every node tracks a balance factor

    balance factor = height(left subtree) − height(right subtree)

• Balance factor must be −1, 0, or +1. If
• Node balance is checked after an insert or delete in the BST – fix it with rotations (restore balance in O(1) time)

AVL Tree – rotation

Primitive rotations:

• LL (Single Left): pivot a node down-right, its left child takes its place
  
• RR (Single Right): pivot a node down-left, its right child takes its place
• LR (Left-Right): Left rotation on child, then right on parent
• RL (Right-Left): Right rotation on child, then left on parent

AVL Tree – disadvantages

• AVL trees are strictly balanced
• Rotations on insert and delete

Red-Black Tree – coloring rules

Every node is colored red or black. The tree must satisfy:

1. Every node is red or black
2. The root is black
   
3. Every null leaf is black (treat nulls as black sentinel nodes)
4. A red node’s children must both be black (no two reds in a row)
   
5. Every path from a node to any descendant null has the same number of black nodes (called black-height)

Red-Black trees accept a looser balance guarantee in exchange for fewer rotations: at most 2 rotations on insert, 3 on delete.

Red-Black Tree – fixing violations

After insert (new nodes start red to avoid breaking black-height):

• Uncle is red → recolor parent, uncle black; grandparent red. Push the problem up the
  tree. O(log n) recolorings but no rotations.
  
• Uncle is black → 1–2 rotations + recoloring. Problem solved locally.

Binary Tree summary

  ┌──────────────┬────────────┬────────────┬────────────┬─────────────────┐
  │  Structure   │   Insert   │   Search   │   Delete   │    Guarantee    │     
  ├──────────────┼────────────┼────────────┼────────────┼─────────────────┤                 
  │ BST          │ O(n) worst │ O(n) worst │ O(n) worst │ None            │
  ├──────────────┼────────────┼────────────┼────────────┼─────────────────┤                 
  │ Binary Heap  │ O(log n)   │ O(n)       │ O(log n)   │ Complete tree   │
  ├──────────────┼────────────┼────────────┼────────────┼─────────────────┤                 
  │ Balanced BST │ O(log n)   │ O(log n)   │ O(log n)   │ Height-balanced │
  └──────────────┴────────────┴────────────┴────────────┴─────────────────┘ 
  

Graph

• A graph contains nodes and edges (like a tree)
• unlike a tree, a graph can have loops
• we call graph “nodes” vertices – A, B, C, D and E are vertices

Simple and multigraphs

• Simple graphs have their nodes connected by only one link/edge

Simple and multigraphs

• Simple graphs have their nodes connected by only one link/edge
• Multigraphs can have multiple types of links/edges between nodes/vertices

Simple and multigraphs

• Simple graphs have their nodes connected by only one link/edge
• Multigraphs can have multiple types of links/edges between nodes/vertices

Weighted Graph

• A graph is considered weighted if it has numbers associated with edges. Weighted graphs are particularly useful for applications such as mapping between two locations, to take into consideration traffic, distance, time, etc.
• Here is an example weighted graph of airline flights, with the weights representing the miles between airports

Direct vs. Undirected

• if the vertices represent people at a party, and there is an edge between two people if they shake hands, then this graph is undirected because any person A can shake hands with a person B only if B also shakes hands with A.
• if an edge from a person A to a person B means that A owes money to B, then this graph is directed, because owing money is not necessarily reciprocated.

Undirected Graph

Any person can shake hands with another person only if that other person also shakes hands with the first person.

Direct Graph

if an edge from a person A to a person B means that A owes money to B, then this graph is directed, because owing money is not necessarily reciprocated.