[AVL Tree][avl-tree] is a type of [balanced binary search tree](../searching/binary-search.md) which is early invented data structure in binary search solutions. It requires a stable property that the absolute difference between the _height_ of the _left_ subtree of _root_ and the _height_ of the _right_ subtree of _root_ is no larger than 1.

_Formal Claim_:

For every [AVL Tree][avl-tree] with 𝓃 nodes, its _height_ 𝒽 ⩽ 2 ⋅ log(n).

_**Proof**_:

define _N_h_ is the minimum number of nodes in an AVL Tree of _height_ h, then

_N_h_ = 1 + _N_h-1_ + _N_h-2_, _N_h_ > 2 _N_h-2_

Obviously, n = &Theta;(2^h/2) (given that _N_h_ = n, _N₀_ = 1, _N₁_ = 2), h < 2 &sdot; log(n)

_A more subtle claim_:

a [AVL Tree][avl-tree] has most height of 1.44 &sdot; log(n + 2).

_**Proof**_:

_N_h_ has a lower bound &Omega;(k^h), then

substituting _c &sdot; k^h_ with both sides of the recurrence relation above yields:

c &sdot; k^h &les; 1 + c &sdot; k^h-1 + c &sdot; k^h-2 = &Tau;(n)

in which to find out a _c, h₀_ such that for every _h_ > _h₀_, the inequality above holds.

Divided both sides by c &sdot; k^h-2:

k² &les; k^2-h/c + k + 1

wherein the term k^2-h becomes relatively small when h grows very large, then the inequality will be satisfied if value of k is smaller than the solution to the equation: k² = k + 1, which is the [golden ratio](https://en.wikipedia.org/wiki/Golden_ratio) &phi; = 1.618... &ap; 1.62

Hence, n = &Omega;(&phi;^h), conversely, h = &Omicron;(log_&phi;n) &ap; 1.44 &sdot; log (n + 2)

comparing with [Red-Black Tree](red-black-tree.md), [AVL Tree][avl-tree] has a better lookup performance given its relative shorter _height_ of the tree: 1.44 &sdot; log(n + 2) < 2 &sdot; log(n + 1);

While the Red-Black Tree requires less costs during tree adjustments when INSERTION or DELETION operations happen than the AVL Tree does;

In conclusion, the AVL Tree is performant if used in scenarios where the number of element lookup dominates the number of element updates.

[avl-tree]: #avl-tree

[Heap](#heap) is a widely adopted data structure in various computing applications such as priority queues, heap sort^{[[1]](https://en.wikipedia.org/wiki/Heap_(data_structure))} and so on.

Inherited from general [tree](overview.md) structure, a heap is either a [max-heap or a min-heap](#max-heap-and-min-heap). Normally, the heap is referred as binary heap, theoretical tree-like, which could be stored in either a static or dynamic structure such as a static array, tree nodes.

It is mostly favored to use a static array structure given that INSERTION operations of new entries always happen in a row from left-side of the tree to the right-side of the tree, which means the heap structure is nearly a [complete binary tree](overview.md) fully filled except the leaf level. Figuratively,

<figure style="text-align:center">

<img src="../images/binary_heap.png" />

<figcaption>Figure 1. Binary Heap in a Static Array Implementation</figcaption>

</figure>

New elements will be promptly appended to the end of the array and entry removal only happens at the _root_. And these operations will incur the [heap maintenance steps](#heap-property-maintenance) to ensure its status as a [max-heap or min-heap](#max-heap-and-min-heap)

_Note: There are certain operations to take such as PARENT(i) = i/2, which is the index of node i's parent; LEFT(i) = 2i, which is the index of node i's left child; RIGHT(i) = 2i + 1, which is the index of node i's right child_.

In a max heap, the key of a node is larger than or equal to the keys of its children. The largest element is stored in root. Specifically, given an array _A_ for entry storage:

_A[PARENT(i)]_ &ges; _A[i]_

Similarly, a min heap will have keys of nodes are smaller than their children. The smallest entry is stored in root. Then,

_A[PARENT(i)]_ &les; _A[i]_

In a [Heap Sort](../sorting/heap-sort.md) algorithm, the max heap is chosen while the min heap is generally common in building a [priority queue](http://pages.cs.wisc.edu/~vernon/cs367/notes/11.PRIORITY-Q.html).

_Note: only max heap data structure is used in further discussions_.

A MAX-HEAPIFY is a critical process for heap property maintenance. Given an array A and an index i, assuming LEFT(i) and RIGHT(i) are both max heap. Then, MAX-HEAPIFY is called upon if A[i] smaller than its children in order to adjust the position of A[i] in the total heap to maintain the overall max heap property.

It is worth noted that MAX-HEAPIFY operation should only be performed where a single heap property violation happens. In a top-down fashion,

<pre>

<code>

MAX_HEAPIFY(A, i)

l = left(i)

r = right(i)

if l &les; heap-size(A) and A[l] > A[i]

largest = l

else

largest = i

if r &les; heap-size(A) and A[r] > A[largest]

largest = r

if largest &ne; i

swap A[i] and A[largest]

MAX_HEAPIFY(A, largest)

</code>

</pre>

_Note: recursive calls happen because after swapping the current index i entry with left or right child, the corresponding right or left sub-tree could have a new heap property violation_.

The operations before each call of MAX_HEAPIFY take constant time, and the total number of calls on MAX_HEAPIFY is bounded by &Omicron;(_h_), wherein _h_ is the height of the heap. Therefore, the time complexity of MAX_HEAPIFY operation is &Omicron;(log(n)) for a n-entry heap.

Given an unordered inputs _A_ stored in a static array structure, build a max heap from it involves iterative calls to MAX_HEAPIFY operation. Specifically,

wherein all leaves of the heap are between the index length(A)/2 + 1 to length(A). The overall process is a bottom-up fashion and generate the max heap regardless of the number of heap property violations.

At the bottom level of the heap, there are 2^h nodes with each cost none for the heapify operation; at the level above the bottom, there are 2^h-1 nodes with each cost most 1 swapping for the heapify operation, and so on. Figuratively,

<figure style="text-align:center">

<img src="../images/build_max_heap.png" />

<figcaption>Figure 2. Build Max Heap Total Work</figcaption>

</figure>

Then, at the level j, there are 2^h-j nodes with each cost most j swappings for the heapify operation. Counting them up,

<figure style="text-align:center">

<img src="../images/build_max_heap_1.png" />

</figure>

By [infinite geometric series](https://en.wikipedia.org/wiki/Geometric_series#Proof_of_convergence), the sum of j/2^j converges to 2; thus,

&Tau;(n) &les; 2^h+1 = n + 1 = &Omicron;(n)

Obviously, the operation must access each of the inputs during heap building and a more tighter bound will be &Theta;(n).

1. Data Structures: Heaps. https://www.youtube.com/watch?v=t0Cq6tVNRBA

2. Lecture Notes: Heapsort analysis. http://www.cs.umd.edu/~meesh/351/mount/lectures/lect14-heapsort-analysis-part.pdf

When talking about [Tree](#tree) data structure, we normally omit the term _**free**_ that a _free tree_ is an acyclic, connected, undirected [graph](../graph-algorithms/overview.md). And a possibly disconnected acyclic undirected graph is _forest_.

Theorem. 1. A _G = (V, E)_ is an undirected graph, then

1. _G_ is a _free tree_.

2. any two vertices in _G_ are connected through a single path.

3. _G_ is connected, but removing an edge will result in a disconnected graph.

4. _G_ is connected, acyclic and |_E_| = |_V_| - 1.

5. if adding any single edge to |_E_| will cause the graph to form a cycle.

A [Rooted Tree](#rooted-tree-and-ordered-tree) is a _free tree_ that has a virtual topmost node distinguishable from others which called the _root_ of the tree.

The children of a tree node is called the _descendant_ of that node and every children call their parent node the _ancestor_. Child nodes under the same node call each other _siblings_ and node with no children is called _leaf_ (external node), a non-leaf node is _internal node_.

The length of a path from _root_ of a tree to a node x is the _**depth**_ of x in the tree (the _**depth**_ of _root_ is 0). The _**height**_ of a node in a tree is the value of longest path leading from that node to a leaf in the tree; it generalizes to a formula for computing:

&hscr;(x) = max( &hscr;(_left subtree of x_), &hscr;(_right subtree of x_)) + 1

An [ordered tree](#rooted-tree-and-ordered-tree) is a rooted tree in which children of each node are ordered. e.g. a node in a tree has _k_ children, then it has 1^th, 2^nd, .. k^th child.

_Note: most of the tree data structure we use is a **rooted tree** for analysis simplicity._

A [Binary tree](#binary-and-k-ary-tree) is defined on a set of nodes that either contains no nodes or is composed with the _root_ node, its connected left subtree and a corresponding right subtree.

In a binary tree structure, filling all missing children of nodes with empty nodes of no descendants will result in a structure called _**full binary tree**_.

For trees that have more than 2 children per node, every node (includeing the _root_) in such a tree has no more than _k_ number of children. It is termed as a _k_-ary Tree.

A _**complete k-ary tree**_ is a tree in which all leaves have the same _depth_ and all non-leaf nodes have _k_ direct children.

* [AVL Tree](avl-tree.md) - a trivial implementation of a balanced binary tree.

* [Red-Black Tree](red-black-tree.md) - a prevalent balanced binary tree implementation.

* [Heap](heap.md) - a special tree structure facilitates various applications such as [priority queue](https://en.wikipedia.org/wiki/Priority_queue) and [heap sort](../sorting/heap-sort.md).

[Red Black Tree][red-black-tree] is a type of [balanced binary search tree][binary-search-tree]. It adds a bit to stand for the _color_: RED or BLACK, of each node.

_Formal Def_:

A [Red Black Tree][red-black-tree] is a type of [binary search tree][binary-search-tree] that follows the properties below:

1. Each node is either RED or BLACK

2. The _root_ is BLACK

3. All leaf nodes (NIL) are BLACK

4. If a node is RED, both of its children are BLACK

5. Every path from a node to its leaves contains the same number of BLACK nodes (_Def: the number of black nodes from a chosen node &xscr; to a NIL leaf (node &xscr; is not included) is called the **black-height**_ (bh(&xscr;)) of such node, the number of black nodes from **root** to any NIL leaves is the **black-height** of the total red-black tree)

_Formal Claim_:

For every [red-black tree][red-black-tree] with &nscr; nodes, its height &hscr; &les; 2 &sdot; log₂ (n + 1).

_**Proof**_:

First, there are at least 2^bh(x) - 1 number of internal nodes rooted from node x.

By simple induction, the base case: if height of tree x is 0, then there is 2⁰ - 1 = 0; for tree with height more than 0 with both child nodes, there are at least 2^{bh(x) - 1} - 1 internal nodes for each child node. Therefore, a rooted tree from x has at least 2 * (2^{bh(x) - 1} - 1) + 1 = 2^bh(x) - 1.

Presumably, for a given tree with height &hscr;, any paths leading from root to leaves have at least half of the nodes are black, in other words, the bh(_root_) &ges; &hscr;/2; then

_n_ &ges; 2^&hscr;/2 - 1, &hscr; &les; 2 log(n+1)

guarantee holds, proof ends.

[red-black-tree]: #red-black-tree

[binary-search-tree]: ../searching/binary-search.md