Tree data structure
In computer science, a tree is a widely-used computer data structure that emulates a tree structure with a set of linked nodes. Each node has zero or more child nodes, which are below it in the tree (in computer science, unlike in nature, trees grow down, not up). A node that has a child is called the child's parent node. A child has at most one parent; a node without a parent is called the root node (or root). Nodes with no children are called leaf nodes.
In graph theory, a tree is a connected acyclic graph. A rooted tree is such a graph with a vertex singled out as the root. In this case, any two vertices connected by an edge inherit a parent-child relationship. An acyclic graph with multiple connected components or a set of rooted trees is sometimes called a forest.
There are two basic types of tree. In an unordered tree, there is no distinction between the various children of a node --- none is the "first child" or "last child". A tree in which such distinctions are made is called an ordered tree, and data structures built on them are called ordered tree data structures. Ordered trees are by far the commonest form of tree data structure.
Binary trees are one kind of ordered tree, and there is a one-to-one mapping between binary trees and general ordered trees.
There are many different ways to represent trees; common representations represent the nodes as records allocated on the heap with pointers to their children, their parents, or both, or as items in an array, with relationships between them determined by their positions in the array (e.g., binary heap).
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 where the operation happens to a node before it happens to its children is called a breadth first walk; a walk where the children are operated upon before the parent is called a depth first walk. See also tree traversal for a discussion of pre-order, in-order and post-order traversal.
Common operations on trees are:
- enumerating all the items;
- searching for an item;
- adding a new item at a certain position on the tree;
- deleting an item;
- removing a whole section of a tree (called pruning);
- adding a whole section to a tree (called grafting);
- finding the root for any node.
Common uses for trees are:
- to manipulate hierarchichal data;
- to make information easily searchable (see also: tree search algorithm);
- to manipulate sorted lists of data.
Examples
Related Terms
- Binary space partitioning
- heap
- tree (graph theory)
- tree search algorithm
- tree structure
- exponential tree
External links
- Description (http://www.nist.gov/dads/HTML/tree.html) from the Dictionary of Algorithms and Data Structures
- STL-like C++ tree class (http://www.damtp.cam.ac.uk/user/kp229/tree/)
- List of data structures (http://www2.informatik.uni-halle.de/lehre/leda/MANUAL/List_data_structures.html) from LEDA
de:Baum (Graphentheorie) es:Árbol (estructura de datos) nl:Tree [[ja:木構造 (データ構造)]] [[zh:树 (数据结构)]]
Categories: Data structures | Graph theory | Trees (structure)