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). The node of which a node is a child is called its 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.

In a tree data structure, 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**.

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.

- to manipulate hierarchichal data;
- to make information easily searchable (see also: tree search algorithm;
- to manipulate sorted lists of data.