# Binary tree

In computer science, a **binary tree** is a tree data structure in which each node has at most two children. Typically the child nodes are called *left* and *right*. One common use of binary trees is binary search trees; another is binary heaps.

## Contents

## Definitions for rooted trees

A directed edge connects the parent to the child.

A node that has no children is called a leaf.

The **depth** of a node n is the length of the path from the root to the node. The set of all nodes at a given depth is sometimes called a **level** of the tree.

The **height** of a node n is the length of the path from the node n to its furthest leaf.

Nodes that share parents are called **siblings**.

If a path exists from node p to node q, then p is an **ancestor** of q and q is a **descendant** of p.

The **size** of a node is the number of descendants it has including itself.

## Types of binary tree

A **binary tree** is a **rooted** tree in which every node has at most two children.

A **full binary tree** is a tree in which every node has zero or two children.

A **perfect binary tree** is a complete binary tree in which **leaves** (vertices with zero children) are at the same **depth** (distance from the **root**, also called **height**).

Sometimes the **perfect binary tree** is called the **complete binary tree**. Some others define a **complete binary tree** to be a full binary tree in which all leaves are at depth *n* or *n-1* for some *n*.

## Definition in graph theory

Graph theorists typically use the following definition: A binary tree is a connected acyclic graph such that the degree of each vertex is no more than 3. It can be shown that in any binary tree, there are exactly two more nodes of degree one than there are of degree three, but there can be any number of nodes of degree two. A **rooted binary tree** is such a graph that has one of its vertices of degree no more than 2 singled out as the root.

With the root thus chosen, each vertex will have a uniquely defined parent, and up to two children; however, so far there is insufficient information to distinguish a left or right child. If we drop the connectedness requirement, allowing multiple connected components in the graph, we call such a structure a forest.

Another way of defining binary trees is a recursive definition on directed graphs. A binary tree is either:

- A single vertex.
- A graph formed by taking two binary trees, adding a vertex, and adding an edge directed from the new vertex to the root of each binary tree.

This also does not establish the order of children, but does fix a specific root node.

## Methods for storing binary trees

Binary trees can be constructed from programming language primitives in several ways. In a language with records and references, binary trees are typically constructed by having a tree node structure which contains some data and references to its left child and its right child. Sometimes it also contains a reference to its unique parent. If a node has fewer than two children, some of the child pointers may be set to a special null value, or to a special sentinel node.

Binary trees can also be stored in arrays, and if the tree is a complete binary tree, this method wastes no space. In this compact arrangement, if a node has an index *i*, its children are found at indices 2*i*+1 and 2*i*+2, while its parent (if any) is found at index *floor((i-1)/2)* (assuming the root has index zero). This method benefits from more compact storage and better locality of reference, particularly during a preorder traversal. However, it requires contiguous memory, is expensive to grow, and wastes space proportional to 2^{h} - *n* for a tree of height *h* with *n* nodes.

In languages with tagged unions such as ML, a tree node is often a tagged union of two types of nodes, one of which is a 3-tuple of data, left child, and right child, and the other of which is a "leaf" node, which contains no data and functions much like the null value in a language with pointers.

## Methods of iterating over binary trees

Often, one wishes to visit each of the nodes in a tree and examine the value there. There are several common orders in which the nodes can be visited, and each has useful properties that are exploited in algorithms based on binary trees.

### Pre-order, in-order, and post-order traversal

*Main article: Tree traversal.*

Pre-order, in-order, and post-order traversal visit each node in a tree by recursively visiting each node in the left and right subtrees of the root. If the root node is visited before its subtrees, this is preorder; if after, postorder; if between, in-order. In-order traversal is useful in binary search trees, where this traversal visits the nodes in increasing order.

### Depth-first order

In depth-first order, we always attempt to visit the node farthest from the root that we can, but with the caveat that it must be a child of a node we have already visited. Unlike a depth-first search on graphs, there is no need to remember all the nodes we have visited, because a tree cannot contain cycles. Preorder, in-order, and postorder traversal are all special cases of this. See depth-first search for more information.

### Breadth-first order

Contrasting with depth-first order is breadth-first order, which always attempts to visit the node closest to the root that it has not already visited. See Breadth-first search for more information.

## Encoding n-ary trees as binary trees

There is a one-to-one mapping between general ordered trees and binary trees, which in particular is used by Lisp to represent general ordered trees as binary trees. Each node *N* in the ordered tree corresponds to a node *N'* in the binary tree; the *left* child of *N is the node corresponding to the first child of *

**N**is the node corresponding to the N's next sibling --- that is, the next node in order among the children of the parent of

*, and the*right*child of*N*N*

One way of thinking about this is that each node's children are in a linked list, chained together with their *right* fields, and the node only has a pointer to the beginning or head of this list, through its *left* field.

For example, in the tree on the left, A has the 6 children {B,C,D,E,F,G}. It can be converted into the binary tree on the right.

The binary tree can be thought of as the original tree tilted sideways, with the black left edges representing *first child* and the blue right edges representing *next sibling*. The leaves of the tree on the left would be written in Lisp as:

- (((M N) H I) C D ((O) (P)) F (L))

which would be implemented in memory as the binary tree on the right, without any letters on those nodes that have a left child.

## See also

da:binært søgetræ de:Binärbaum es:Árbol binario fr:Arbre binaire ko:이진_트리 pl:Drzewo binarne sl:dvojiško drevo sv:Binärträd uk:Бінарне дерево zh:二叉树