Data Structures

Full Tree

A tree in which every level of the tree is completely full, with no missing nodes.

Maximum Heap Tree

A tree in which every parent is greater in value than both its children, which means that the root of the tree is greatest value in the tree.

Minimum Heap Tree

A tree in which every parent is lesser in value than both its children, which means that the root of the tree is least value in the tree.

Binary Search Tree

A tree in which nodes are inserted systematically in natural order, with the final property of each left child being less than or equal to its parent, and each right child being greater than its parent. (Does not preserve the order in which nodes were added.

Complete Tree

A tree in which there are no missing nodes when looking at each level of the tree. The lowest level of tree may not be completely full, but may not have any missing nodes. All other levels are full.

Tree Topology

A tree is widely used abstract data type (ADT) or data structure implementing this ADT that simulates a hierarchical tree structure, with a root value and subtrees of children with a parent node, represented as a set of linked nodes.

Head

A typical object variable identifier name used to reference, or point to, the first object in a linked list. The number one rule for processing linked lists is, 'Never let go of the head of the list!", otherwise all of the list is lost in memory. The number two rule when managing linked lists is, 'Always connect before you disconnect!'.

Array Index

A value that indicates the position in the array of a particular value. The last element in a zero-indexed array would be the length of the array, minus 1.

Array length

A value that represents the number of elements contained in an array. Often there is a process associated with an array that provides this value, such as list.length, or len(list).

Data Structure

A way of organizing data in a computer so that it can be used efficiently, such as an array, linked list, stack, queue, or binary tree.

Stack

An abstract data type that serves as a collection of elements, with two principal operations: push, which adds an element to the collection, and pop, which removes the last element that was added. LIFO - Last In First Out

2D Array

An array of an arrays, characterized by rows and columns, arranged in a grid format, but still stored in contiguous, or side-by-side memory, accessed using two index values.

Ragged Array

An array where the number of columns in each row may be different.

Row Major

An array where the two index values for any element are the row first, then the column.

Internal Node

An existing node in a tree, either the root or any one of the children in the tree.

Vertex

An object in a graph.

Node

An object linked to other objects, representing some entity in that data structure.

1D Array

A linear collection of data items in a program, all of the same type, such as an array of integers or an array of strings, stored in contiguous memory, and easily accessed using a process called indexing.

Linked List

A linear data structure, much like an array, that consists of nodes, where each node contains data as well as a link to the next node, but that does not use contiguous memory.

Leaf

A node in a tree data structure that has no children, and is at the end of a branch in a tree.

Parent Node

A node, including the root, which has one or more child nodes connected to it.

Full Tree Traversal

A non-executable, visual approach to help determine the pre-order, in-order, or post-order traversal of a tree.

Heapify

A process in Minimum Heap Trees where the new node is switched up until min heap state is achieved.

Pop

A process used in stack and queue processing where a copy of the top or front value is acquired, and then removed from the stack or queue (Dequeue).

Static Memory

Memory allocated to an array, which cannot grow or shrink once declared.

Contiguous Memory

Memory that is "side-by-side" in a computer, typical of an array structure.

Dynamic Memory

Memory that is allocated as needed, and NOT contiguous (side-by-side), specifically during the implementation of a linked list style data structure, which also includes binary trees and graphs.

Root

The base level node in a tree; the node that has no parent.

Edge

The connection in a graph between two vertices.

Queue

A FIFO (First In First Out) data structure, where the first element added will be the first to be removed, and where a new element is added to the back, much like a waiting line.

Graph

A data structure in programming which consists of a set of vertices (nodes) and edges (connections).

Binary Tree

A data structure that consists of nodes, with one root node at the base of the tree, and two nodes (left child and right child) extending from the root, and from each child node.

Non-Linear Data Structure

A data structure that does not occupy contiguous memory, such as a linked list, graph, or tree.

Undirected Graph

A graph that contains edges between vertices with no specific direction associated with any edge.

Directed Graph

A graph where an edge has a direction associated with it, for example, a plane flight that takes off in one location and arrives in another. The return flight would be considered a separate edge.

Connected Graph

A graph where there exists a simple path from any vertex in the graph to any other vertex in the graph, even if it takes several "hops" to get there.

External Node

A potential node in a tree, where currently either the left or right child pointer of a node is pointing to null, but potentially could reference another node.

Peek

A process used in stack and queue processing where a copy of the top or front value is acquired, without removing that item.

Push

A process used in stack and queue processing where a new value is inserted onto the top of the stack OR into the back of the queue (Enqueue).

Linear Data Structure

A programming data structure that occupies contiguous memory, such as an array of values.

Complete Graph

A simple undirected graph in which every pair of distinct vertices is connected by a unique edge, in other words, every vertex is directly connected to every other vertex in the graph

Aggregate Data Types

Any type of data that can be referenced as a single entity, and yet consists of more than one piece of data, like strings, arrays, classes, and other complex structures.

Depth

In tree data structure, expressed as the number of steps from the root of the tree to the farthest outlying node in the tree. Height is also used to mean the same thing.

Internal Path Length

In tree processing, this is the sum of all the lengths from the root to the external nodes in a tree.

In-Order Traversal

The process of systematically visiting every node in a tree once, starting at the root and proceeding left down the tree, accessing the first node encountered at its "center", proceeding likewise along the tree, accessing each node as encountered at the "center".

Post-Order Traversal

The process of systematically visiting every node in a tree once, starting at the root and proceeding left down the tree, accessing the first node encountered at its "right" side, proceeding likewise along the tree, accessing each node as encountered at its "right" side.

Pre-Order Traversal

The process of systematically visiting every node in a tree once, starting with the root node, proceeding to the left along the tree and accessing the node when the "left" side of the node is encountered.

Binary Tree Traversal

The process of systematically visiting every node in a tree once. The three most common traversals are: pre-order, in-order, and post-order.

Children

The term used in trees to indicate a node that extends from another node, such as left child and right child in a binary tree.