Tree (abstract data type)

A node is a structure which may contain data and connections to other nodes, sometimes called edges or links. Each node in a tree has zero or more child nodes, which are below it in the tree (by convention, trees are drawn with descendants going downwards). A node that has a child is called the child's parent node (or superior). All nodes have exactly one parent, except the topmost root node, which has none. A node might have many ancestor nodes, such as the parent's parent. Child nodes with the same parent are sibling nodes. Typically siblings have an order, with the first one conventionally drawn on the left. Some definitions allow a tree to have no nodes at all, in which case it is called empty. An internal node (also known as an inner node, inode for short, or branch node) is any node of a tree that has child nodes. Similarly, an external node (also known as an outer node, leaf node, or terminal node) is any node that does not have child nodes. The height of a node is the length of the longest downward path to a leaf from that node. The height of the root is the height of the tree. The depth of a node is the length of the path to its root (i.e., its root path). Thus the root node has depth zero, leaf nodes have height zero, and a tree with only a single node (hence both a root and leaf) has depth and height zero. Conventionally, an empty tree (tree with no nodes, if such are allowed) has height −1. Each non-root node can be treated as the root node of its own subtree, which includes that node and all its descendants. Other terms used with trees: ==Common operations==

• Enumerating all the items • Enumerating a section of a tree • Searching for an item • Adding a new item at a certain position on the tree • Deleting an item • Pruning: Removing a whole section of a tree • Grafting: Adding a whole section to a tree • Finding the root for any node • Finding the lowest common ancestor of two nodes Traversal and search methods Stepping through the items of a tree, by means of the connections between parents and children, is called walking the tree, and the action is a walk of the tree. Often, an operation might be performed when a pointer arrives at a particular node. A walk in which each parent node is traversed before its children is called a pre-order walk; a walk in which the children are traversed before their respective parents are traversed is called a post-order walk; a walk in which a node's left subtree, then the node itself, and finally its right subtree are traversed is called an in-order traversal. (This last scenario, referring to exactly two subtrees, a left subtree and a right subtree, assumes specifically a binary tree.) A level-order walk effectively performs a breadth-first search over the entirety of a tree; nodes are traversed level by level, where the root node is visited first, followed by its direct child nodes and their siblings, followed by its grandchild nodes and their siblings, etc., until all nodes in the tree have been traversed. ==Representations==

There are many different ways to represent trees. In working memory, nodes are typically dynamically allocated records with pointers to their children, their parents, or both, as well as any associated data. If of a fixed size, the nodes might be stored in a list. Nodes and relationships between nodes might be stored in a separate special type of adjacency list. In relational databases, nodes are typically represented as table rows, with indexed row IDs facilitating pointers between parents and children. Nodes can also be stored as items in an array, with relationships between them determined by their positions in the array (as in a binary heap). A binary tree can be implemented as a list of lists: the head of a list (the value of the first term) is the left child (subtree), while the tail (the list of second and subsequent terms) is the right child (subtree). This can be modified to allow values as well, as in Lisp S-expressions, where the head (value of first term) is the value of the node, the head of the tail (value of second term) is the left child, and the tail of the tail (list of third and subsequent terms) is the right child. Ordered trees can be naturally encoded by finite sequences, for example with natural numbers. ==Examples of trees and non-trees==

As an abstract data type, the abstract tree type with values of some type is defined, using the abstract forest type (list of trees), by the functions: : value: → : children: → : nil: () → : node: × → with the axioms: : value(node(, )) = : children(node(, )) = In terms of type theory, a tree is an inductive type defined by the constructors (empty forest) and (tree with root node with given value and children). ==Mathematical terminology==

Viewed as a whole, a tree data structure is an ordered tree, generally with values attached to each node. Concretely, it is (if required to be non-empty): • A rooted tree with the "away from root" direction (a more narrow term is an "arborescence"), meaning: • A directed graph, • whose underlying undirected graph is a tree (any two vertices are connected by exactly one simple path), • with a distinguished root (one vertex is designated as the root), • which determines the direction on the edges (arrows point away from the root; given an edge, the node that the edge points from is called the parent and the node that the edge points to is called the child), together with: • an ordering on the child nodes of a given node, and • a value (of some data type) at each node. Often trees have a fixed (more properly, bounded) branching factor (outdegree), particularly always having two child nodes (possibly empty, hence at most two non-empty child nodes), hence a "binary tree". Allowing empty trees makes some definitions simpler, some more complicated: a rooted tree must be non-empty, hence if empty trees are allowed the above definition instead becomes "an empty tree or a rooted tree such that ...". On the other hand, empty trees simplify defining fixed branching factor: with empty trees allowed, a binary tree is a tree such that every node has exactly two children, each of which is a tree (possibly empty). ==Applications==

Trees are commonly used to represent or manipulate hierarchical data in applications such as: • File systems for: • Directory structure used to organize subdirectories and files (symbolic links create non-tree graphs, as do multiple hard links to the same file or directory) • The mechanism used to allocate and link blocks of data on the storage device • Class hierarchy or "inheritance tree" showing the relationships among classes in object-oriented programming; multiple inheritance produces non-tree graphs • Abstract syntax trees for computer languages • Natural language processing: • Parse trees • Modeling utterances in a generative grammar • Dialogue tree for generating conversations • Document Object Models ("DOM tree") of XML and HTML documents • Search trees store data in a way that makes an efficient search algorithm possible via tree traversal • A binary search tree is a type of binary tree • Representing sorted lists of data • Computer-generated imagery: • Space partitioning, including binary space partitioning • Digital compositing • Storing Barnes–Hut trees used to simulate galaxies • Implementing heaps • Nested set collections • Hierarchical taxonomies such as the Dewey Decimal Classification with sections of increasing specificity. • Hierarchical temporal memory • Genetic programming • Hierarchical clustering Trees can be used to represent and manipulate various mathematical structures, such as: • Paths through an arbitrary node-and-edge graph (including multigraphs), by making multiple nodes in the tree for each graph node used in multiple paths • Any mathematical hierarchy Tree structures are often used for mapping the relationships between things, such as: • Components and subcomponents which can be visualized in an exploded-view drawing • Subroutine calls used to identify which subroutines in a program call other subroutines non recursively • Inheritance of DNA among species by evolution, of source code by software projects (e.g. Linux distribution timeline), of designs in various types of cars, etc. • The contents of hierarchical namespaces JSON and YAML documents can be thought of as trees, but are typically represented by nested lists and dictionaries. ==See also==