Loading…

1.
A*: a heuristic search algorithm that attempts to find a desired goal using a heuristic function to estimate the distance from a given node to the goal.

2.
abstract data type: a description of operations on a data type that could have multiple possible implementations.

3.
acyclic: describes a graph with no cycles (circular paths).

4.
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.

5.
adjacency matrix: a representation of a graph in which a boolean matrix contains a 1 at position (i,j) iff there is an arc from node i to node j.

6.
ancestors: in a tree, the union of a node's parent and the parent's ancestors.

7.
arc: a link between two nodes in a graph.

8.
array: a contiguous block of memory containing elements of the same type, accessed by numeric index.

9.
association list: a list of pairs, where each pair has a key and a value associated with the key.

10.
AVL tree: a self-balancing sorted binary tree, in which the heights of subtrees differ by at most 1.

11.
backtrack: in a tree search, to move back from the node currently being examined to its parent.

12.
balanced tree: a tree in which the heights of subtrees are approximately equal.

13.
bandwidth: information transfer rate of a network connection, in bits/second.

14.
base case: a simple case that can be solved easily, without recursion.

15.
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.

16.
bijective: describes a relation that is both injective and surjective (one-to-one and onto).

17.
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.

18.
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.

19.
binary tree: a tree in which each node has at most two children.

20.
binding: an association of a name with a value.

21.
binding list: a list structure that represents a set of bindings.

22.
Boolean matrix: a matrix whose elements are 0 or 1.

23.
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.

24.
branching factor: in a search tree, the number of children of a given node. Individual nodes will vary, so an average value may be used.

25.
B-tree: a tree with a high branching factor, to minimize the number of disk accesses required to access a desired record.

26.
bucket: a collection, such as a linked list, of values that hash to the same value.

27.
cache: to save a value locally to save re-computing or transferring it in the future.

28.
Cartesian product: a set of pairs (x, y) of elements from two sets X and Y.

29.
child: in a tree, a node pointed to by a parent node.

30.
circularly linked list: a linked list in which the last element points back to the first element.

31.
circular queue: a queue implemented within an array, where the first element of the array logically follows the last element.

32.
class: in object-oriented programming, a description of a set of similar objects.

33.
clustering: a situation in which many elements hash to the same hash value.

34.
collision: when two values to be stored in a hash table have the same hash value.

35.
comparison: the act of comparing two values to determine which is greater according to some ordering.

36.
cons: 1. in Lisp, the function that constructs a pair of pointers, or basic element of list structure. 2. to make a cons data structure. 3. a cons data structure.

37.
constructive: describes a function that makes a new data structure but does not modify its arguments.

38.
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.

39.
cycle: a circular path in a graph.

40.
DAG: directed acyclic graph.

41.
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. sparse graph.

42.
depth: the number of links between the root of a tree and the leaves.

43.
depth-first search: a search in which children of a node are considered (recursively) before siblings are considered.

44.
dereference: to convert from a pointer (address) to the data that is pointed to.

45.
descendants: all nodes below a given node in a tree.

46.
design pattern: a pattern that describes a set of similar programs.

47.
destructive: describes a function that modifies its arguments.

48.
DFS: depth-first search.

49.
Dijkstra's algorithm: an optimal greedy algorithm to find the minimum distance and shortest path in a weighted graph from a give start node.

50.
directed: describes an arc that can only be traversed in one direction, or a graph with such arcs.

51.
directed acyclic graph: a directed graph with no cycles.

52.
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.

53.
divide and conquer: a problem-solving strategy in which a problem is broken down into sub-problems, until simple subproblems are reached.

54.
domain: the set of values that are the source values of a mapping.

55.
doubly linked list: a linked list in which each element has both forward and backward pointers.

56.
edge: a link or arc between nodes in a graph.

57.
exclusive or: a binary Boolean function whose output is 1 if its inputs are different. Abbreviated XOR.

58.
extendible hashing: another term for hashing with buckets.

59.
external sort: a sort using external storage in addition to main memory.

60.
fair: describes a process in which every arriving customer will eventually be served.

61.
FIFO: first-in, first-out: describes the ordering of a queue.

62.
filter: a process that removes unwanted elements from a collection.

63.
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.

64.
fold: to process a set of items using a specified function; another term for reduce.

65.
garbage: storage that is no longer pointed to by any variable and therefore can no longer be accessed.

66.
garbage collection: the process of collecting garbage for recycling.

67.
gedanken: describes a thought experiment or view of an entity.

68.
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 + ...

69.
goal: an item (or description of items) being sought in a search.

70.
grammar: a formal description of a language in terms of vocabulary and rules for writing phrases and sentences.

71.
graph: a set of nodes and arcs connecting the nodes.

72.
greedy algorithm: an algorithm that always tries the solution path that appears to be the best.

73.
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.

74.
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.

75.
heuristic search: A* search.

76.
immutable: describes a data structure that cannot be changed once it has been created, such as Integer or String in Java.

77.
injective: describes a mapping in which each element of the domain maps to a single element of the range. Also, one-to-one.

78.
inorder: an order of processing a tree in which the parent node is processed in between its children.

79.
in-place: describes a sort that does not require any additional memory.

80.
insertion sort: an O(n^2) search algorithm that's similar to the way people sort playing cards. Stable, in-place and on-line. First removes element from list, inserts it in the correct position, and repeats until finished.

81.
interior node: a node of a tree that has children.

82.
internal sort: a sort using only the main memory of the computer.

83.
intersection: given two sets, the set of elements that are members of both sets.

84.
intractable: a problem that is so hard (typically exponential) that it cannot be solved unless the problem is small.

85.
iterator: an object containing data and methods to iterate through a collection of data, allowing processing of one data item at a time.

86.
latency: the delay between asking for data from an I/O device and the beginning of data transfer.

87.
leaf: a tree node containing a contents value but with no children.

88.
LIFO: last-in, first out: describes the order of a stack.

89.
linear: name for O(n) algorithm

90.
link: a pointer to the next element in a linked list.

91.
linked list: a sequence of records, where each record contains a link to the next one.

92.
load factor: in a hash table, the fraction of the table's capacity that is filled.

93.
map: in MapReduce, a program that processes an element of the input and emits one or more (key, value) pairs.

94.
mapping: association of one or more elements of a Range set with each element of a Domain set.

95.
master: a program that controls a set of other programs or devices.

96.
max queue: a priority queue in which the maximum element is removed first.

97.
memory hierarchy: the use of several kinds of memory hardware in a computer system, where the fastest memory (e.g. cache) is smallest, slower memory (e.g. RAM) is larger, and the slowest memory (e.g. disk) is largest.

98.
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.

99.
merge: to combine two ordered linear structures into one.

100.
merge sort: O(n*log(n)) search algorithm; stable, not in-place; breaks data in half, sorts, merges, repeats.

101.
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.

102.
min queue: a priority queue in which the minimum element is removed first.

103.
node: an element of a linked list, tree, or graph, often represented by a data structure.

104.
null dereference: a runtime error that occurs when an operation such as a method call is attempted on a null pointer.

105.
object: a data structure that can be identified at runtime as being a member of a class.

106.
one-to-one: describes a mapping in which each element of the domain maps to a single element of the range. Also, injective.

107.
on-line: describes a sorting algorithm that can process items one at a time.

108.
onto: describes a mapping in which each element of the range is the target of some element of the domain. Also, surjective.

109.
ontology: a description of the kinds of objects that exist in a computer program, e.g. a Java class hierarchy.

110.
operator: in a search tree, a program that changes a state into a child state, e.g. a move in a game.

111.
parent: in a tree, a node that points to a given node.

112.
parsing: analysis of a sentence of a language to determine the elements of the sentence and their relationship and meaning.

113.
path: a sequence of steps along arcs in a graph.

114.
pattern: a representation of a class of objects, containing some constant elements in relation to variable elements.

115.
pattern variable: a part of a pattern that can match variable parts of an input.

116.
pivot: in Quicksort, a "center" value used in partitioning the set to be sorted.

117.
pointer: a variable containing the address of other data.

118.
postorder: an order of processing a tree in which the parent node is processed after its children.

119.
preorder: an order of processing a tree in which the parent node is processed before its children.

120.
priority queue: a queue in which the highest-priority elements are removed first; within a priority value, the earliest arrival is removed first.

121.
quadratic: name for a O(n^2) algorithm

122.
queue: a data structure representing a sequence of items, which are removed in the same order as they were inserted.

123.
quick sort: O(n*log(n)) search algorithm; in-place, not stable. Picks a pivot, reorders so lesser objects are in front of pivot, recursively sorting sub-lists of lesser and sub-lists of greater values.

124.
radix sort: an O(n*k) search algorithm where K = keylength. Stable. Sorts input into bins based on the lowest digit; then combines bins in order and sorts on the next highest digit & so forth.

125.
random access: describes a data structure or device in which all accesses have the same cost, O(1).

126.
randomized algorithm: an algorithm in which the data to be processed or the device to process it is randomly selected.

127.
range: a set of values that are the targets of a mapping.

128.
recursion: a case where a program calls itself.

129.
recursive case: a condition of the input data where the data will be handled by call(s) to the same program.

130.
Red-Black tree: a self-balancing binary tree in which nodes are "colored" red or black. The longest path from the root to a leaf is no more than twice the length of the shortest path.

131.
reduce: to apply a given function to the elements of a given list. Also, fold.

132.
reference: a pointer to data.

133.
reference type: a type in which variables of that type are pointers to objects.

134.
rehash: to apply a different hashing function to a key when a collision occurs.

135.
root: the top node of a tree, from which all other nodes can be reached.

136.
runtime stack: a stack containing a stack frame of variable values for each active invocation of a procedure.

137.
scalability: the ability of an algorithm or hardware system to grow to handle a larger number of inputs.

138.
search: to look through a data structure until a goal object is found.

139.
sentinel: an extra record at the start or end of a data structure such as a linked list, to simplify the processing.

140.
set difference: given two sets, the set of elements of the first set that are not members of the second set.

141.
shadow: to hide similar items with the same name.

142.
shortest path: the shortest path between a start node and a goal node in a weighted graph. <

143.
side-effect: any effect of a procedure other than returning a value, e.g. printing or modifying a data structure.

144.
simple path: a path between two nodes in a graph that does not revisit any intermediate node.

145.
slack: in a PERT chart or scheduling graph, the amount of time by which the time of an activity could be increased without affecting the overall completion time.

146.
slave: a program or device that operates under control of a master.

147.
sort: to modify the order of a set of elements so that a desired ordering holds between them, e.g. alphabetic order.

148.
sparse array: an array in which most of the elements are zero or missing.

149.
sparse graph: a graph in which any node is connected to relatively few other nodes. cf. dense graph.

150.
spatial locality: being close together in space, i.e. memory address.

151.
Splay tree: a self-balancing binary tree that places recently accessed elements near the top of the tree for fast access.

152.
stable: describes a sort algorithm in which the relative position of elements with equal keys is unchanged after sorting.

153.
stack frame: a section of the runtime stack holding the values of all variables for one invocation of a procedure.

154.
stack space: the amount of space on the runtime stack required for execution of a program.

155.
state: a description of the state of a process, such as a board game.

156.
structure sharing: a case where two data structures share some elements.

157.
successor: the next element in a linked list.

158.
surjective: describes a mapping in which each element of the range is the target of some element of the domain. Also, onto.

159.
symbol table: a data structure that links names to information about the objects denoted by the names.

160.
tail recursive: a function whose value either does not involve a recursive call, or is exactly the value of a recursive call.

161.
taxonomy: a classification of objects into a tree structure that groups related objects.

162.
temporal locality: being close together in time, i.e. memory accesses that occur within a short time of each other.

163.
topological sort: a linear ordering of nodes of an acyclic graph, such that a node follows all of its graph predecessors in the ordering.

164.
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.

165.
undirected: describes a graph in which the arcs may be followed in either direction.

166.
union: given two sets, the set of elements that are members of either set.

167.
unparsing: converting an abstract syntax tree into a sentence in a language, such as a programming language.

168.
vertex: a node in a graph.

169.
weight: a number that denotes the cost of following an arc in a graph.

170.
well-founded ordering: an ordering that can be guaranteed to terminate, e.g. starting at a positive integer and counting down to 0.

171.
XML: Extensible Markup Language, a way of writing data in a tree-structured form by enclosing it in tags.

172.
XOR: exclusive or.

## CS 314 Final Exam Vocabulary TermsStudy online at quizlet.com/_afvgf |

table

glossary

Print the PDF. Fold each page down the middle along the dotted vertical line and cut the solid horizontal lines.

If your printer has a special "duplex" option, you can use it to automatically print double-sided. However for most printers, you need to:

**Print the "odd-numbered" pages first**- Feed the printed pages back into the printer
- Print the "even-numbered" pages

**If your printer prints pages face up**, you may need to tell your printer to reverse the order when printing the even-numbered pages.

Please use the "Open PDF" button to print your set.

**Why?**
In order to provide a consistent printing experience across different computers and web browsers, we've provided a standard PDF format for you to print.

Create Set
or
### Need an account?

Sign up for free