| Terms |
Definitions |
|
XOR
|
exclusive or.
|
|
Reference
|
A pointer to data
|
|
LIFO
|
last-in, first-out, describes the order of a stack
|
|
Vertex
|
A node in a graph
|
|
Quadratic
|
O(n^2), a problem whose solution requires a quadratic amount of time or space if the problem is of size n.
|
|
Queue
|
A data structure representing a sequence of items, which are removed in the same order as they were inserted.
|
|
Array
|
A contiguous block of memory containing elements of the same type, accessed by numeric index
|
|
Filter
|
A process that removes unwanted elements from a collection.
|
|
Unparsing
|
Converting an abstract syntax tree into a sentence in a language, such as programming language
|
|
Fair
|
describes a process in which every arriving customer will eventually be served
|
|
Taxonomy
|
A classification of objects into a tree structure that groups related objects
|
|
Successor
|
The next element in a linked list.
|
|
Immutable
|
Describes a data structure that cannot be changed once it has been created, such as Integer or String in Java.
|
|
Pointer
|
A variable containing the address of other data.
|
|
Gedanken
|
Describes a thought experiment or view of an entity.
|
|
Big O
|
An abstracted function that describes the amount of computer time or memory space required by an algorithm, as a function of problem size. For problems larger than a certain size, the actual time or space required will be less than the Big O multiplied by some constant.
|
|
Rehash
|
To apply a different hashing function to a key when a collision occurs
|
|
Bandwidth
|
Information transfer rate of a network connection, in bits/second
|
|
Heuristic
|
A function that estimates the distance from a given node to the goal in A* search. More generally, a method that generally gives good advice about which direction to go or how to approach a problem
|
|
Scalability
|
The ability of an algorithm or hardware system to grow to handle a larger number of inputs
|
|
Extendible hashing
|
Another term for hashing with buckets
|
|
Pattern
|
A representation of a class of objects, containing some constant elements in relation to variable elements
|
|
Onto
|
Describes a mapping in which each element of the range is the target of some element of the domain. Also, surjective
|
|
One-to-one
|
Describes a mapping in which each element of the domain maps to a single element of the range. Also, injective.
|
|
Circular Queue
|
a queue implemented within an array, where the first element of the array logically follows the last element.
|
|
Grammar
|
a formal description of a language in terms of vocabulary and rules for writing phrases and sentences.
|
|
Intractable
|
A problem that is so hard (typically exponential) that it cannot be solved unless the problem is small.
|
|
Linked List
|
a sequence of records, where each record contains a link to the next one.
|
|
Intersection
|
Given to sets, the intersection is the set of elements that are members of both sets.
|
|
Operator
|
In a search tree, a program that changes a state into a child state, e.g. a move in a game.
|
|
Garbage
|
Storage that is no longer pointed to by any variable and therefore can no longer be accessed.
|
|
State
|
A description of the state of a process, such as a board game.
|
|
Dereference
|
To convert from a pointer (address) to the data that is pointed to.
|
|
Bucket
|
A collection, such as a linked list, of values that hash to the same value.
|
|
Latency
|
The delay between asking for data from an I/O device and the beginning of data transfer
|
|
Clustering
|
A situation in which many elements has to the same hash value
|
|
Dijkstra's algorithm
|
An optimal greedy algorithm to find the minimum distance and shortest path in a weighted graph from a give start node.
|
|
External Sort
|
A sort using external storage in addition to main memory.
|
|
Pivot
|
In Quicksort, a "center" value used in partition the set to be sorted
|
|
Hash Function
|
A function that is deterministic but randomizing, i.e. whose output is a relatively small integer that appears to be a random function of the key value.
|
|
Directed
|
Describes an arc that can only be traversed in one direction, or a graph with such arcs
|
|
Set difference
|
Given two sets, the set difference is the set of elements of the first set that are not members of the second set.
|
|
Runtime Stack
|
A stack containing a stack frame of variable values for each active invocation of a procedure.
|
|
Preorder
|
An order of processing a tree in which the parent node is processed before its children.
|
|
Postorder
|
An order of processing a tree in which the parent node is processed after its children.
|
|
Tail Recursive
|
A function whose value either does not involve a recursive call, or is exactly the value of a recursive call.
|
|
Structure Sharing
|
A case where two data structures share some elements.
|
|
Ancestors
|
in a tree, the union of a node's parent and the parent's ancestors.
|
|
Well-founded ordering
|
An ordering that can be guaranteed to terminated, e.g. starting at positive integer and counting down to 0
|
|
Union
|
Given two sets, the union is the set of elements that are members of either set.
|
|
Design pattern
|
A pattern that describes a set of similar programs.
|
|
First-child/next sibling
|
a way of implementing trees that uses two pointers per node but can represent an arbitrary number of children of a node.
|
|
Sort
|
To modify the order of a set of elements so that a desired ordering holds between them, e.g. alphabetic order.
|
|
Binary search
|
search of a binary tree or other structure, in which the size of the set to be searched is cut in half at each step.
|
|
Adjacency list
|
A representation of a graph in which each node has a list of nodes that are adjacent to it, i.e. connected to it by an arc.
|
|
Symbol Table
|
A data structure that links names to information about the objects denoted by the names
|
|
Topoligical Sort
|
A linear ordering of nodes of an acyclic graph, such that a node follows all of its graph predecessors in the ordering.
|
|
Geometric series
|
A series in which each successive term is multiplied by a constant less than 1. e.g. 1 + 1/2 + 1/4 + 1/8
|
|
Fold
|
To process a set of items using a specified function; another term for reduce
|
|
Range
|
A set of values that are the targets of a mapping
|
|
Root
|
The top node of a tree, from which all other nodes can be reached.
|
|
Child
|
In a tree, a node pointed to by a parent node.
|
|
parent
|
In a tree, a node that points to a given node.
|
|
Reference Type
|
A type in which variables of that type are pointers to objects.
|
|
Tree Rotation
|
Changing the links in a binary tree to change the relative heights of the child subtrees, while leaving the sort order of the tree unchanged.
|
|
Internal sort
|
A sort using only the main memory of the computer
|
|
Collision
|
When two values to be stored in a hash table have the same hash value.
|
|
Sparse Graph
|
a graph in which any node is connected to relatively few other nodes.
|
|
Simple Path
|
A path between two nodes in a graph that does not revisit any intermediate node.
|
|
Discrete event simulation
|
A simulation in terms of events, in which the highest-priority (least time) event is removed from an event queue and executed, which may have the effect of scheduling future events.
|
|
Association List
|
A list of pairs, where each pair has a key and a value associated with the key.
|
|
Minimum spanning tree
|
A tree formed from the nodes of a graph and a subset of its edges, such that all nodes are connected and the total cost of the edges is minimal
|