Close
Register
Close Window

| About   Contents

Index

Symbols | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | Z

Symbols

2-3 tree
80/20 rule

A

abstract data type
activation record
acyclic graph
address
adjacency list
adjacency matrix
adjacent
ADT
adversary
adversary argument
aggregate type
algorithm
algorithm analysis
all-pairs shortest paths problem
allocated
allocation
alphabet trie
amortized analysis
amortized cost
ancestor
antisymmetric
arm
array-based list
array-based queue
array-based stack
ASCII character coding
asymptotic algorithm analysis
asymptotic analysis
attribute
automatic variable
average case
average seek time
AVL Tree

B

B$^*$-tree
B$^+$-tree
B-tree
backing storage
bag
balanced tree
base
base case
base class
base type
basic operation
best case
best fit
BFS
big-Oh notation
binary search
binary search tree
binary search tree property
binary tree
binary trie
binning
Binsort
bintree
block
Boolean variable
boom
bounding box
breadth-first search
break-even point
BST
bubble sort
bucket
bucket hashing
bucket sort
buddy method
buffer
buffer passing
buffer pool
buffering

C

caching
call stack
Cartesian product
ceiling
child
circular first fit
circular list
class
class hierarchy
client
clique
closed hash system
closed-form solution
cluster
cohesion
collision
collision resolution
collision resolution policy
comparable
comparator
comparison
compile-time polymorphism
complete binary tree
complete graph
Composite design pattern
composite type
composition
computability
computational complexity theory
connected component
connected graph
constant running time
constructive induction
container
container class
cost
cost model
CPU
current position
cycle
cylinder
cylinder index
cylinder overflow

D

DAG
data field
data item
data member
data structure
data type
deallocated
deallocation
decision problem
decision tree
deep copy
degree
delegation mental model for recursion
dense graph
depth
depth-first search
depth-first search tree
dequeue
dereference
descendant
deserialization
design pattern
deterministic algorithm
DFS
dictionary
digraph
Dijkstra's algorithm
diminishing increment sort
direct access
direct proof
directed acyclic graph
directed edge
directed graph
dirty bit
discriminator
disjoint
disjoint sets
disk access
disk controller
disk drive
disk I/O
disk-based space/time tradeoff
distance
divide and conquer
divide-and-conquer recurrences
divide-and-guess
domain
double buffering
double hashing
double rotation
doubly linked list
DSA
dynamic
dynamic allocation
dynamic array
dynamic memory allocation
dynamic programming

E

edge
efficient
element
empirical comparison
empty
encapsulation
enqueue
entry-sequenced file
enumeration
equivalence class
equivalence relation
estimation
exact-match query
exceptions
exchange
exchange sort
expanding the recurrence
exponential growth rate
expression tree
extent
external fragmentation
external sort

F

factorial
failure policy
FIFO
file allocation table
file manager
file processing
file structure
FIND
first fit
fixed-length coding
floor
Floyd's algorithm
flush, [1]
flyweight
folding method
forest
free block
free block list
free store
free tree
freelist
frequency count
full binary tree theorem
full tree
function

G

garbage
garbage collection
general tree
graph
greedy algorithm
growth rate
guess-and-test
guided traversal

H

halting problem
handle
hard algorithm
hard problem
harmonic series
hash function
hash system
hash table
hashing
head
header node
heap
Heapsort
height
height balanced
heuristic
home position
home slot
homogeneity
Huffman codes
Huffman coding tree
Huffman tree

I

I/O head
image space decomposition
in degree
incident
index file
indexing
induction hypothesis
induction step
induction variable
information theoretic lower bound
inherit
inode
inorder traversal
Insertion Sort
instance variable
inter-sector gap
internal fragmentation
internal node
internal sort
inversion
inverted file
inverted list
irreflexive
ISAM
iterator

J

job

K

K-ary tree
k-path
kd tree
key
key sort
key space
key space decomposition
key-value pair
Kruskal's algorithm

L

labeled graph
Las Vegas algorithms
leaf node
least frequently used
least recently used
length
level
lexical scoping
LFU
lifetime
LIFO
linear growth rate
linear index
linear order
linear probing
linear probing by steps
linear search
linked list
linked stack
list
load factor
local storage
local variable
local variables
locality of reference
logarithm
logical file
logical form
lookup table
lower bound
lower bounds proof
LRU

M

main memory
map
mapping
mark array
mark/sweep algorithm
master theorem
max heap
maximum lower bound
MCST
measure of cost
member
member function
memory allocation
memory deallocation
memory hierarchy
memory leak
memory manager
memory pool
memory request
Mergesort
message
message passing
metaphor
method
mid-square method
min heap
minimal-cost spanning tree
minimum external path weight
mod
model
modulus
Monte Carlo algorithms
move-to-front
MST
multi-dimensional search key
multi-dimensional search structure
multilist

N

necessary fallacy
neighbor
node
non-deterministic algorithm
non-deterministic choice
non-deterministic polynomial time algorithm
non-strict partial order
NP
NP-Complete
NP-Completeness proof
NP-hard

O

object
object space decomposition
object-oriented programming paradigm
Omega notation
one-way list
open addressing
open hash system
operating system
optimal static ordering
out degree
overflow
overflow bucket
overhead

P

page
parameter
parent
parent pointer representation
parity
parity bit
partial order
partially ordered set
partition
pass by reference
pass by value
path
path compression
peripheral storage
permutation
persistent
physical file
physical form
Pigeonhole Principle
pivot
platter
point quadtree
point-region quadtree
pointee
pointer
pointer-based implementation for binary tree nodes
polymorphism
pop
poset
position
postorder traversal
potential
powerset
PR quadtree
prefix property
preorder traversal
Prim's algorithm
primary clustering
primary index
primary key
primary key index
primary storage
primitive data type
primitive element
priority
priority queue
probabilistic algorithm
probabilistic data structure
probe function
probe sequence
problem
problem instance
problem lower bound
problem upper bound
procedural
procedural programming paradigm
program
promotion
proof, [1]
by contradiction
by induction
direct
proof by contradiction
proof by induction
proving the contrapositive
pseudo-random probing
push

Q

quadratic growth rate
quadratic probing
quadtree
queue
Quicksort

R

radix
radix sort
RAM
random access
random access memory
random permutation
randomized algorithm
range
range query
read/write head
rebalancing operation
record
recurrence relation
recurrence with full history
recursion
recursive call
recursive data structure
recursive function
Red-Black Tree
reduction
reference
reference count algorithm
reference parameter
reflexive
relation
replacement selection
reserved block
resource constraints
root
rotation
rotational delay
rotational latency
run
run file
run-time polymorphism
runtime environment
runtime stack

S

search key
search lower bound
search tree
search trie
secondary clustering
secondary index
secondary key
secondary key index
secondary storage
sector
sector header
seek
selection sort
self-organizing list
self-organizing list heuristic
separate chaining
sequence
sequential access
sequential fit
sequential search
sequential tree representation
serialization
set
set product
shallow copy
Shellsort
shifting method
shortest path
sibling
signature
simple cycle
simple path
simple type
simulating recursion
single rotation
single-source shortest paths problem
singly linked list
skip list
slot
snowplow argument
software engineering
software reuse
sorted list
sorting
lower bounds proof
sorting lower bound
sorting problem
space/time tradeoff
sparse graph
sparse matrix
spatial
spatial application
spatial attribute
spatial data
spatial data structure
spindle
Splay Tree
splaying
stable
stack
stack frame
stack variable
stale pointer
static
Strassen's algorithm
strategy
stream
strict partial order
strong induction
subclass
subgraph
subset
subtract-and-guess
subtree
successful search
summation
superset
symmetric
symmetric matrix

T

tail
Theta notation
tombstone
topological sort
total order
Towers of Hanoi problem
track
track-to-track seek time
trailer node
transitive
transpose
traversal
tree
tree traversal
trie
truth table
tuple
two-coloring
type

U

underflow
undirected edge
undirected graph
uninitialized
UNION
UNION/FIND
unsolveable problem
unsorted list
unsuccessful search
unvisited
upper bound

V

value parameter
variable-length coding
vector
vertex
virtual memory
visit
visited
visitor
volatile

W

weight
weighted graph
weighted path length
weighted union rule
working memory
worst case
worst fit

Z

zigzig
Zipf distribution
zone

   Contents

nsf
Close Window