Skip to main content
Mathematics LibreTexts

10.4: Binary Trees

  • Page ID
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    \( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)

    ( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\id}{\mathrm{id}}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\kernel}{\mathrm{null}\,}\)

    \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\)

    \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\)

    \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    \( \newcommand{\vectorA}[1]{\vec{#1}}      % arrow\)

    \( \newcommand{\vectorAt}[1]{\vec{\text{#1}}}      % arrow\)

    \( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vectorC}[1]{\textbf{#1}} \)

    \( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)

    \( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)

    \( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)

    \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    Definition of a Binary Tree

    An ordered rooted tree is a rooted tree whose subtrees are put into a definite order and are, themselves, ordered rooted trees. An empty tree and a single vertex with no descendants (no subtrees) are ordered rooted trees.

    Example \(\PageIndex{1}\): Distinct Ordered Rooted Trees

    The trees in Figure \(\PageIndex{1}\) are identical rooted trees, with root 1, but as ordered trees, they are different.

    clipboard_e20c96fad3a2d8bd0a740e2b30161f39d.pngFigure \(\PageIndex{1}\): Two different ordered rooted trees

    If a tree rooted at \(v\) has \(p\) subtrees, we would refer to them as the first, second,..., \(p^{th}\) subtrees. There is a subtle difference between certain ordered trees and binary trees, which we define next.

    Definition \(\PageIndex{1}\): Binary Tree

    1. A tree consisting of no vertices (the empty tree) is a binary tree
    2. A vertex together with two subtrees that are both binary trees is a binary tree. The subtrees are called the left and right subtrees of the binary tree.

    The difference between binary trees and ordered trees is that every vertex of a binary tree has exactly two subtrees (one or both of which may be empty), while a vertex of an ordered tree may have any number of subtrees. But there is another significant difference between the two types of structures. The two trees in Figure \(\PageIndex{2}\) would be considered identical as ordered trees. However, they are different binary trees. Tree (a) has an empty right subtree and Tree (b) has an empty left subtree.

    clipboard_ef19a1d98877a4631a131310b14685f3b.pngFigure \(\PageIndex{2}\): Two different binary trees

    List \(\PageIndex{1}\): Terminology and General Facts about Binary Trees

    1. A vertex of a binary tree with two empty subtrees is called a leaf. All other vertices are called internal vertices.
    2. The number of leaves in a binary tree can vary from one up to roughly half the number of vertices in the tree (see Exercise \(\PageIndex{4}\) of this section).
    3. The maximum number of vertices at level \(k\) of a binary tree is \(2^k\) , \(k\geq 0\) (see Exercise \(\PageIndex{6}\) of this section).
    4. A full binary tree is a tree for which each vertex has either zero or two empty subtrees. In other words, each vertex has either two or zero children. See Exercise \(\PageIndex{7}\) of this section for a general fact about full binary trees.

    Traversals of Binary Trees

    The traversal of a binary tree consists of visiting each vertex of the tree in some prescribed order. Unlike graph traversals, the consecutive vertices that are visited are not always connected with an edge. The most common binary tree traversals are differentiated by the order in which the root and its subtrees are visited. The three traversals are best described recursively and are:

    Definition \(\PageIndex{2}\): Preorder Traversal

    1. Visit the root of the tree.
    2. Preorder traverse the left subtree.
    3. Preorder traverse the right subtree.

    Definition \(\PageIndex{3}\): Inorder Traversal

    1. Inorder traverse the left subtree.
    2. Visit the root of the tree.
    3. Inorder traverse the right subtree.

    Definition \(\PageIndex{4}\): Postorder Traversal

    1. Postorder traverse the left subtree.
    2. Postorder traverse the right subtree.
    3. Visit the root of the tree.

    Any traversal of an empty tree consists of doing nothing.

    Example \(\PageIndex{2}\): Traversal Examples

    For the tree in Figure \(\PageIndex{3}\), the orders in which the vertices are visited are:

    • A-B-D-E-C-F-G, for the preorder traversal.
    • D-B-E-A-F-C-G, for the inorder traversal.
    • D-E-B-F-G-C-A, for the postorder traversal.
    clipboard_ebd0f8ef2775aa6c8a4d40c91a450c3ff.pngFigure \(\PageIndex{3}\): A Complete Binary Tree to Level 2

    Binary Tree Sort. Given a collection of integers (or other objects than can be ordered), one technique for sorting is a binary tree sort. If the integers are \(a_1\text{,}\) \(a_2, \ldots \text{,}\) \(a_n\text{,}\) \(n\geq 1\text{,}\) we first execute the following algorithm that creates a binary tree:

    Algorithm \(\PageIndex{1}\): Binary Sort Tree Creation

    1. Insert \(a_1\) into the root of the tree.
    2. For k := 2 to n // insert \(a_k\) into the tree
      1. r = \(a_1\)
      2. inserted = false
      3. while not(inserted):
        \(\quad \)if \(a_k < r\text{:}\)
        \(\quad \quad \quad \)if \(r\) has a left child:
        \(\quad \quad \quad \quad\)r = left child of \(r\)
        \(\quad \quad \quad\) else:
        \(\quad \quad \quad \quad\)make \(a_k\) the left child of \(r\)
        \(\quad \quad \quad \quad\)inserted = true
        \(\quad \quad\)else:
        \(\quad \quad \quad \)if \(r\) has a right child:
        \(\quad \quad \quad \quad\)r = right child of \(r\)
        \(\quad \quad \quad\) else:
        \(\quad \quad \quad \quad\)make \(a_k\) the right child of \(r\)
        \(\quad \quad \quad \quad\)inserted = true

    If the integers to be sorted are 25, 17, 9, 20, 33, 13, and 30, then the tree that is created is the one in Figure \(\PageIndex{4}\). The inorder traversal of this tree is 9, 13, 17, 20, 25, 30, 33, the integers in ascending order. In general, the inorder traversal of the tree that is constructed in the algorithm above will produce a sorted list. The preorder and postorder traversals of the tree have no meaning here.

    clipboard_ea8e7b78f73cedcafa4a485d15eae9f28.pngFigure \(\PageIndex{4}\): A Binary Sorting Tree

    Expression Trees

    A convenient way to visualize an algebraic expression is by its expression tree. Consider the expression

    \begin{equation*} X = a*b - c/d + e. \end{equation*}

    Since it is customary to put a precedence on multiplication/divisions, \(X\) is evaluated as \(((a*b) -(c/d)) + e\text{.}\) Consecutive multiplication/divisions or addition/subtractions are evaluated from left to right. We can analyze \(X\) further by noting that it is the sum of two simpler expressions \((a*b) - (c/d)\) and \(e\text{.}\) The first of these expressions can be broken down further into the difference of the expressions \(a*b\) and \(c/d\text{.}\) When we decompose any expression into \((\textrm{left expression})\textrm{operation} (\textrm{right expression})\text{,}\) the expression tree of that expression is the binary tree whose root contains the operation and whose left and right subtrees are the trees of the left and right expressions, respectively. Additionally, a simple variable or a number has an expression tree that is a single vertex containing the variable or number. The evolution of the expression tree for expression \(X\) appears in Figure \(\PageIndex{5}\).

    clipboard_e762973865cfaa47958794d3b6419f5a5.pngFigure \(\PageIndex{5}\): Building an Expression Tree

    Example \(\PageIndex{3}\): Some Expression Trees

    1. If we intend to apply the addition and subtraction operations in \(X\) first, we would parenthesize the expression to \(a*(b - c)/(d + e)\text{.}\) Its expression tree appears in Figure \(\PageIndex{6}\)(a).
    2. The expression trees for \(a^2-b^2\) and for \((a + b)*(a - b)\) appear in Figure \(\PageIndex{6}\)(b) and Figure \(\PageIndex{6}\)(c).
    clipboard_ea66227964d09c2db7c5a5ab97b4e2881.pngFigure \(\PageIndex{6}\): Expression Tree Examples

    The three traversals of an operation tree are all significant. A binary operation applied to a pair of numbers can be written in three ways. One is the familiar infix form, such as \(a + b\) for the sum of \(a\) and \(b\text{.}\) Another form is prefix, in which the same sum is written \(+a b\text{.}\) The final form is postfix, in which the sum is written \(a b+\text{.}\) Algebraic expressions involving the four standard arithmetic operations \((+,-,*, \text{and} /)\) in prefix and postfix form are defined as follows:

    List \(\PageIndex{2}\): Prefix and Postfix Forms of an Algebraic Expression


    1. A variable or number is a prefix expression
    2. Any operation followed by a pair of prefix expressions is a prefix expression.


    1. A variable or number is a postfix expression
    2. Any pair of postfix expressions followed by an operation is a postfix expression.

    The connection between traversals of an expression tree and these forms is simple:

    1. The preorder traversal of an expression tree will result in the prefix form of the expression.
    2. The postorder traversal of an expression tree will result in the postfix form of the expression.
    3. The inorder traversal of an operation tree will not, in general, yield the proper infix form of the expression. If an expression requires parentheses in infix form, an inorder traversal of its expression tree has the effect of removing the parentheses.

    Example \(\PageIndex{4}\): Traversing an Expression Tree

    The preorder traversal of the tree in Figure \(\PageIndex{5}\) is \(+-*ab/cd e\text{,}\) which is the prefix version of expression \(X\text{.}\) The postorder traversal is \(ab*cd/-e+\text{.}\) Note that since the original form of \(X\) needed no parentheses, the inorder traversal, \(a*b-c/d+e\text{,}\) is the correct infix version.

    Counting Binary Trees

    We close this section with a formula for the number of different binary trees with \(n\) vertices. The formula is derived using generating functions. Although the complete details are beyond the scope of this text, we will supply an overview of the derivation in order to illustrate how generating functions are used in advanced combinatorics.

    Let \(B(n)\) be the number of different binary trees of size \(n\) (\(n\) vertices), \(n \geq 0\text{.}\) By our definition of a binary tree, \(B(0) = 1\text{.}\) Now consider any positive integer \(n + 1\text{,}\) \(n \geq 0\text{.}\) A binary tree of size \(n + 1\) has two subtrees, the sizes of which add up to \(n\text{.}\) The possibilities can be broken down into \(n + 1\) cases:

    Case 0: Left subtree has size 0; right subtree has size \(n\text{.}\)

    Case 1: Left subtree has size 1; right subtree has size \(n - 1\text{.}\)

    \(\quad \quad \)\(\vdots\)

    Case \(k\text{:}\) Left subtree has size \(k\text{;}\) right subtree has size \(n - k\text{.}\)

    \(\quad \quad \)\(\vdots\)

    Case \(n\text{:}\) Left subtree has size \(n\text{;}\) right subtree has size 0.

    In the general Case \(k\text{,}\) we can count the number of possibilities by multiplying the number of ways that the left subtree can be filled, \(B(k)\text{,}\) by the number of ways that the right subtree can be filled. \(B(n-k)\text{.}\) Since the sum of these products equals \(B(n + 1)\text{,}\) we obtain the recurrence relation for \(n\geq 0\text{:}\)

    \begin{equation*} \begin{split} B(n+1) &= B(0)B(n)+ B(1)B(n-1)+ \cdots + B(n)B(0)\\ &=\sum_{k=0}^n B(k) B(n-k) \end{split} \end{equation*}

    Now take the generating function of both sides of this recurrence relation:

    \[\label{eq:1}\sum\limits_{n=0}^\infty B(n+1)z^n=\sum\limits_{n=0}^\infty\left(\sum\limits_{k=0}^n B(k)B(n-k)\right)z^n\]


    \[\label{eq:2} G(B\uparrow ;z)=G(B*B;z)=G(B;z)^2\]

    Recall that \(G(B\uparrow;z) =\frac{G(B;z)-B(0)}{z}=\frac{G(B;z)-1}{z}\) If we abbreviate \(G(B; z)\) to \(G\text{,}\) we get

    \begin{equation*} \frac{G-1}{z}= G^2 \Rightarrow z G^2- G + 1 = 0 \end{equation*}

    Using the quadratic equation we find two solutions:

    \[\begin{align}\label{eq:3}G_1 &=\frac{1+\sqrt{1-4z}}{2z}\text{ and} \\ \label{eq:4}G_2&=\frac{1-\sqrt{1-4z}}{2z}\end{align}\]

    The gap in our derivation occurs here since we don't presume a knowledge of calculus. If we expand \(G_1\) as an extended power series, we find


    The coefficients after the first one are all negative and there is a singularity at 0 because of the \(\frac{1}{z}\) term. However if we do the same with \(G_2\) we get


    Further analysis leads to a closed form expression for \(B(n)\text{,}\) which is

    \begin{equation*} B(n) = \frac{1}{n+1}\left( \begin{array}{c} 2n \\ n \\ \end{array} \right) \end{equation*}

    This sequence of numbers is often called the Catalan numbers. For more information on the Catalan numbers, see the entry A000108 in The On-Line Encyclopedia of Integer Sequences.

    SageMath Note - Power Series

    It may be of interest to note how the extended power series expansions of \(G_1\) and \(G_2\) are determined using Sage. In Sage, one has the capability of being very specific about how algebraic expressions should be interpreted by specifying the underlying ring. This can make working with various algebraic expressions a bit more confusing to the beginner. Here is how to get a Laurent expansion for \(G_1\) above.


    The first Sage expression above declares a structure called a ring that contains power series. We are not using that whole structure, just a specific element, G1. So the important thing about this first input is that it establishes z as being a variable associated with power series over the integers. When the second expression defines the value of G1 in terms of z, it is automatically converted to a power series.

    The expansion of \(G_2\) uses identical code, and its coefficients are the values of \(B(n)\text{.}\)

    In Chapter 16 we will introduce rings and will be able to take further advantage of Sage's capabilities in this area.


    Exercise \(\PageIndex{1}\)

    Draw the expression trees for the following expressions:

    1. \(\displaystyle a(b + c)\)
    2. \(\displaystyle a b + c\)
    3. \(\displaystyle a b + a c\)
    4. \(\displaystyle b b - 4 a c\)
    5. \(\displaystyle \left(\left(a_3 x + a_2\right)x +a_1\right)x + a_0\)
    clipboard_e3fc5c9467732da1e444d485faa1a3334.pngFigure \(\PageIndex{7}\)
    clipboard_eed8118102b8b48e4af211060fefb0703.pngFigure \(\PageIndex{8}\)

    Exercise \(\PageIndex{2}\)

    Draw the expression trees for

    1. \(\displaystyle \frac{x^2-1}{x-1}\)
    2. \(\displaystyle x y + x z + y z\)

    Exercise \(\PageIndex{3}\)

    Write out the preorder, inorder, and postorder traversals of the trees in Exercise \(\PageIndex{1}\) above.


    \begin{equation*} \begin{array}{cccc} & \text{Preorder} & \text{Inorder} & \text{Postorder} \\ (a) & \cdot a + b c & a\cdot b+c & a b c + \cdot \\ (b) & +\cdot a b c & a\cdot b+c & a b\cdot c+ \\ (c) & +\cdot a b\cdot a c & a\cdot b+a\cdot c & a b\cdot a c\cdot + \\ \end{array} \end{equation*}

    Exercise \(\PageIndex{4}\)

    Verify the formula for \(B(n)\text{,}\) \(0 \leq n \leq 3\) by drawing all binary trees with three or fewer vertices.

    Exercise \(\PageIndex{5}\)

    1. Draw a binary tree with seven vertices and only one leaf.
    2. Draw a binary tree with seven vertices and as many leaves as possible.

    Add texts here. Do not delete this text first.

    clipboard_e07d9d21c4bd5ac54a0e80839263e1bcc.pngFigure \(\PageIndex{9}\)

    Exercise \(\PageIndex{6}\)

    Prove that the maximum number of vertices at level \(k\) of a binary tree is \(2^k\) and that a tree with that many vertices at level \(k\) must have \(2^{k+1}-1\) vertices.

    Exercise \(\PageIndex{7}\)

    Prove that if \(T\) is a full binary tree, then the number of leaves of \(T\) is one more than the number of internal vertices (non-leaves).


    Solution 1:

    Basis: A binary tree consisting of a single vertex, which is a leaf, satisfies the equation \(\text{leaves }=\text{ internal vertices }+1\)

    Induction: Assume that for some \(k\geq 1\), all full binary trees with \(k\) or fewer vertices have one more leaf than internal vertices. Now consider any full binary tree with \(k+1\) vertices. Let \(T_{A}\) and \(T_{B}\) be the left and right subtrees of the tree which, by the definition of a full binary tree, must both be full. If \(i_{A}\) and \(i_{B}\) are the numbers of internal vertices in \(T_{A}\) and \(T_{B}\), and \(j_{A}\) and \(j_{B}\) are the numbers of leaves, then \(j_{A}=i_{A}+1\) and \(j_{B}=i_{B}+1\). Therefore, in the whole tree,

    \[\begin{aligned}\text{the number of leaves }&=j_{A}+j_{B} \\ &=(i_{A}+1)+(i_{B}+1) \\ &=(i_{A}+i_{B}+1)+1 \\ &=(\text{number of internal vertices})+1\end{aligned}\]

    Solution 2:

    Imagine building a full binary tree starting with a single vertex. By continuing to add leaves in pairs so that the tree stays full, we can build any full binary tree. Our starting tree satisfies the condition that the number of leaves is one more than the number of internal vertices . By adding a pair of leaves to a full binary tree, an old leaf becomes an internal vertex, increasing the number of internal vertices by one. Although we lose a leaf, the two added leaves create a net increase of one leaf. Therefore, the desired equality is maintained.

    This page titled 10.4: Binary Trees is shared under a CC BY-NC-SA 3.0 license and was authored, remixed, and/or curated by Al Doerr & Ken Levasseur via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.