| Terms |
Definitions |
|
DFS
|
Depth-first search
|
|
DAG
|
Directed acyclic graph
|
|
FIFO
|
first-in, first-out: describes the ordering of a queue.
|
|
Class
|
In object-oriented programming, a description of a set of similar objects
|
|
Linear
|
O(n), a problem whose solution requires a linear amount of time or space if the problem is of size n.
|
|
Merge
|
To combine two ordered linear structures into one.
|
|
Cycle
|
A circular path in a graph
|
|
Destructive
|
Describes a function that modifies its arguments.
|
|
Cons
|
1. in Lisp, the function that constructs a pair of pointers, or basic element of list structure.2. to make a cons data structure3. a cons data structure
|
|
Object
|
A data structure that can be identified at runtime as being a member of a class.
|
|
Recursion
|
A case where a program calls itself.
|
|
Leaf
|
A tree node containing a contents value but with no children.
|
|
Injective
|
Describes a mapping in which each element of the domain maps to a single element of the range. Also, one-to-one
|
|
Iterator
|
An object containing data and methods to iterate through a collection of data, allowing processing of one data item at a time
|
|
Surjective
|
Describes a mapping in which each element of the range is the target of some element of the domain. Also, onto
|
|
Stable
|
Describes a sort algorithm in which the relative position of elements with equal keys is unchanged after sorting.
|
|
Splay Tree
|
A self-balancing binary tree that places recently accessed elements near the top of the tree for fast access.
|
|
Row-major order
|
a way of storing a multiply-dimensioned array in memory, such that elements of a row are in adjacent memory addresses.
|
|
Map
|
In MapReduce, a program that processes an element of the input and emits one or more (key, value) pairs
|
|
AVL Tree
|
A self-balancing sorted binary tree, in which the heights of subtrees differ by at most 1.
|
|
On-line
|
Describes a sorting algorithm that can process items one at a time
|
|
Shadow
|
To hide similar items with the same name.
|
|
Search
|
To look through a data structure until a goal object is found.
|
|
Ontology
|
A description of the kinds of objects that exist in a computer program, e.g. a Java class hierachy.
|
|
Side-effect
|
Any effect of a procedure other than returning a value, e.g. printing or modifying a data structure.
|
|
Depth
|
the number of links between the root of a tree and the leaves.
|
|
Constructive
|
Describes a function that makes a new data structure but does not modify its arguments.
|
|
Binary Heap
|
A data structure that implements a complete binary tree within an array, such that every parent node has a value that is less than the value of either of its children.
|
|
Cache
|
To save a value locally to save re-computing or transferring it in the future
|
|
Temporal locality
|
Being close together in time, i.e. memory accesses that occur within a short time of each other
|
|
B-Tree
|
a tree with a high branching factor, to minimize the number of disk accesses required to access a desired record.
|
|
Comparison
|
The act of comparing two values to determine which is greater according to some ordering
|
|
Spatial Locality
|
Being close together in space, i.e. memory address
|
|
Greedy algorithm
|
An algorithm that always tries the solution path that appears to be the best
|
|
Excusive Or
|
A binary Boolean function whose output is 1if its inputs are different. Abbreviated XOR.
|
|
Parsing
|
Analysis of a sentence of a language to determine the elements of the sentence and their relationship and meaning
|
|
In-place
|
Describes a sort that does not require any additional memory
|
|
Scope
|
The area of program text over which a variable can be referenced.
|
|
Backtrack
|
In a tree search, to move back from the node currently being examined to its parent.
|
|
Inorder
|
An order of processing a tree in which the parent node is processed in between its children.
|
|
Descendants
|
All nodes below a given node in a tree.
|
|
Stack Space
|
The amount of space on the runtime stack required for execution of a program.
|
|
Base Case
|
A simple case that can be solved easily, without recursion.
|
|
Node
|
An element of a linked list, tree, or graph, often represented by a data structure.
|
|
Link
|
A pointer to the next element in a linked list.
|
|
Interior node
|
A node of a tree that has children.
|
|
Goal
|
A set of nodes and arcs connecting the nodes.
|
|
Shortest path
|
the shortest path between a start node and a goal node in a weighted graph
|
|
Min queue
|
A priority queue in which the minimum element is removed first
|
|
Master
|
A program that controls a set of other programs or devices
|
|
Max queue
|
A priority queue in which the maximum element is removed first.
|
|
Domain
|
The set of values that are the source values of a mapping
|
|
Edge
|
A link or arc between nodes in a graph
|
|
Graph
|
A set of nodes and arcs connecting the nodes
|
|
Balanced Tree
|
A tree in which the heights of subtrees are approximately equal
|
|
Path
|
A sequence of steps along arcs in a graph
|
|
Boxed Number
|
A number that is defined as an object, so that it has a runtime type and methods that can be used. e.g. Integer in Java.
|
|
Sentinel
|
An extra record at the start or end of a data structure such as a linked list, to simplify the processing
|
|
Critical Path
|
In a PERT chart or scheduling graph, a path from the initial state to the goal such that any increase in time required along the critical path will increase the time to complete the whole project.
|
|
Dense Graph
|
A graph such that a large fraction of possible connections among nodes are present, i.e. the number of edges is of the order of the number of vertices squared. cf. sparsh graph.
|
|
Load factor
|
In a hash table, the fraction of the table's capacity that is filled.
|
|
Memory Locality
|
The processing of data in such a way that data that are located near each other by memory address are accessed nearby in time
|
|
Randomized Algorithm
|
An algorithm in which the data to be processed or the device to process it is randomly selected
|
|
Binary Tree
|
A tree in which each node has at most two children.
|
