BINARY TREE

A binary tree is an ordered tree data structure in which each node has at most two children. Typically the child nodes are called left and right. One use of binary trees is as binary search trees.

Graph theorists use the following definition. A binary tree is a connected acyclic graph such that the degree of each vertex is no more than 3. 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, and there are multiple connected component in the graph, we call such a structure a forest.

Methods for storing binary trees

Binary trees can be constructed from programming language primitives in several ways. In a language with structures and either pointers or references, binary trees are constructed by having a tree node structure which contains some data and pointers or references to its left child and its right child. The order this imposes on the children is sometimes useful, particularly for in-order traversal. Sometimes it also contains a pointer to its unique parent. If a node has less 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, and the resulting data structure is called a heap. In this compact arrangement, a node has an index i, and (assuming zero-based arrays) its children are found at indices 2i+1 and 2i+2, while its parent (if any) is found at index floor(i/2). This method benefits from more compact storage and better locality of reference, particularly during a preorder traversal.

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

Say we have a structure TreeNode which contains a value value and references left and right to its two children. Then we can write the following function:

visit(TreeNode node) {
   print node.value
   if node.left  != null then visit(node.left)
   if node.right != null then visit(node.right)
}

This prints the values in the tree in pre-order. In pre-order, each node is visited either any of its children. Similarly, if the print statement was last, each node would be visited after all of its children, and the values would be printed in post-order.

visit(TreeNode node) {
   if node.left  != null then visit(node.left)
   print node.value
   if node.right != null then visit(node.right)
}

Finally, an in-order traversal, as above, visits each node between the nodes in its left subtree and the nodes in its right subtree. This is a particularly common way of traversing a binary search tree, because it gives the values in increasing order.

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, and the right 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 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: AVL tree, B-tree, binary space partition, red-black tree

Frequency of Internet Keywords: BINARY TREE

Modern Translation: BINARY TREE

Anagrams: BINARY TREE

Scrabble® Enable2K-Verified Anagrams
	Words within the letters "a-b-e-e-i-n-r-r-t-y"
	-2 letters: banterer, betrayer, retainer, teaberry.
	-3 letters: arbiter, arenite, barnier, beanery, betaine, rarebit, rebater, reentry, reinter, rentier, retiary, retinae, retrain, tearier, ternary, terrain, terrane, terrine, trainee, trainer, trinary, yearner.
	-4 letters: aerier, artery, artier, baiter, banter, barite, barren, barret, barter, baryte, beanie, bearer, beaten, beater, berate, betray, binary, binate, brainy, brayer, briary, briery, briner, byrnie, earner.
	Words containing the letters "a-b-e-e-i-n-r-r-t-y"
	+2 letters: presbyterian.
	+4 letters: corynebacteria, extraembryonic.
	+5 letters: corynebacterial, corynebacterium, heartbreakingly, intracerebrally.
Source: compiled by the editor from various references; see credits. SCRABBLE® is a registered trademark. All intellectual property rights in and to the game are owned in the U.S.A and Canada by Hasbro Inc., and throughout the rest of the world by J.W. Spear & Sons Limited of Maidenhead, Berkshire, England, a subsidiary of Mattel Inc. Mattel and Spear are not affiliated with Hasbro.

Alternative Orthography: BINARY TREE

Hexadecimal (or equivalents, 770AD-1900s) (references)

42 49 4E 41 52 59 54 52 45 45

Leonardo da Vinci (1452-1519; backwards) (references)

Binary Code (1918-1938, probably earlier) (references)

01000010 01001001 01001110 01000001 01010010 01011001 00100000 01010100 01010010 01000101 01000101

HTML Code (1990) (references)

&#66 &#73 &#78 &#65 &#82 &#89 &#32 &#84 &#82 &#69 &#69

ISO 10646 (1991-1993) (references)

0042 0049 004E 0041 0052 0059 0054 0052 0045 0045

Encryption (beginner's substitution cypher): (references)

Domain	Definition
Computing	Binary tree (btree) A tree in which each node has at most two successors or child nodes. In Haskell this could be represented as data BTree a = NilTree \| Node a (BTree a) (BTree a) See also balanced tree. (1994-11-29). Source: The Free On-line Dictionary of Computing.
Math	A tree with at most two children for each node. (references)
Source: compiled by the editor from various references; see credits.

Expression	Frequency per Day
binary tree	51
binary tree c++	8
binary tree walking	3
balanced binary tree	2
Source: compiled by the editor from various references; see credits.

Language		Translations for "BINARY TREE"; alternative meanings/domain in parentheses.
Japanese Kanji		二進木 , 二分木 . (various references)

Japanese Katakana		にし�"ぎ, にぶ�"ぎ. (various references)

Pig Latin		inarybay eetray
Source: compiled by the editor from various translation references.

BINARY TREE

Specialty Definition: BINARY TREE

Computing

Math

Specialty Definition: Binary tree

Methods for storing binary trees

Methods of iterating over binary trees

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

Depth-first order

Breadth-first order

Encoding n-ary trees as binary trees

Crosswords: BINARY TREE

Frequency of Internet Keywords: BINARY TREE

binary tree

binary tree c++

binary tree walking

balanced binary tree

Modern Translation: BINARY TREE

Japanese Kanji

Japanese Katakana

Pig Latin

Anagrams: BINARY TREE

Scrabble® Enable2K-Verified Anagrams

Alternative Orthography: BINARY TREE

42 49 4E 41 52 59 54 52 45 45

01000010 01001001 01001110 01000001 01010010 01011001 00100000 01010100 01010010 01000101 01000101

&#66 &#73 &#78 &#65 &#82 &#89 &#32 &#84 &#82 &#69 &#69

0042 0049 004E 0041 0052 0059 0054 0052 0045 0045

364348355259254523939

INDEX