Close
Register
Close Window

Programming Languages

| 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
accept
accepting state
activation record
acyclic graph
address
adjacency list
adjacency matrix
adjacent
ADT
adversary
adversary argument
aggregate type
algorithm
algorithm analysis
alias
all-pairs shortest paths problem
allocated
allocation
Alonzo Church
alpha-conversion
alphabet
alphabet trie
amortized analysis
amortized cost
ancestor
antisymmetric
approximation algorithm
arm
array-based list
array-based queue
array-based stack
ASCII character coding
assembly code
asymptotic algorithm analysis
asymptotic analysis
attribute
automata
automatic variable
average case
average seek time
AVL Tree

B

B∗-tree
B+-tree
B-tree
backing storage
backtracking
bag
balanced tree
base
base case
base class
base type
basic operation
best case
best fit
BFS
big-Oh notation
binary insert sort
binary search
binary search tree
binary search tree property
binary tree
binary trie
binning
Binsort
bintree
bit vector
bitmap
block
BNF grammar
double recursion and ambiguity
Boolean expression
Boolean variable
boom
bounding box
branch-and-bounds algorithm
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
clause
client
clique
closed
closed hash system
closed-form solution
cluster
CNF
code generation
code optimization
cohesion
Collatz sequence
collision
collision resolution
collision resolution policy
comparable
comparator
comparison
compile-time polymorphism
compiler
complete binary tree
complete graph
complex number
Composite design pattern
composite type
composition
computability
computation
computational complexity theory
configuration
Conjunctive Normal Form
connected component
connected graph
constant running time
constructive induction
container
container class
context-free grammar
context-free language
context-sensitive grammar
cost
cost model
countable
countably infinite
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
derivation
descendant
deserialization
design pattern
deterministic
deterministic algorithm
Deterministic Finite Acceptor
Deterministic Finite Automata
DFA
DFS
DFT
diagonalization argument
dictionary
dictionary search
digraph
Dijkstra's algorithm
diminishing increment sort
direct access
direct proof
directed acyclic graph
directed edge
directed graph
dirty bit
Discrete Fourier Transform
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
edit distance
efficient
element
empirical comparison
empty
encapsulation
enqueue
entry-sequenced file
enumeration
equidistribution property
equivalence class
equivalence relation
estimation
evaluation
exact-match query
exceptions
exchange
exchange sort
expanding the recurrence
exponential growth rate
expression tree
extent
external fragmentation
external sort

F

factorial
failure policy
family of languages
FIFO
file allocation table
file manager
file processing
file structure
final state
FIND
Finite Automata
Finite State Acceptor
Finite State Automata
Finite State Machine
first fit
fixed-length coding
floor
Floyd's algorithm
flush, [1]
flyweight
folding method
Ford and Johnson sort
forest
free block
free block list
free store
free tree
freelist
frequency count
FSA
FSM
full binary tree theorem
full tree
function
functional programming
lambda calculus

G

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

H

halt state
halted configuration
halting problem
handle
hanging configuration
hard algorithm
hard problem
harmonic series
hash function
hash system
hash table
hashing
head
header node
heap
Heapsort
height
height balanced
heuristic
heuristic algorithm
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
initial state
inode
inorder traversal
Insertion Sort
instance variable
integer function
inter-sector gap
intermediate code
intermediate code generation
internal fragmentation
internal node
internal sort
interpolation
interpolation search
interpreter
inversion
inverted file
inverted list
irreflexive
ISAM
iterator

J

job
jump search

K

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

L

labeled graph
lambda calculus
BNF grammar
anonymous function
function abstraction
function application
lambda abstraction
parentheses
syntax
variable
language
Las Vegas algorithms
leaf node
least frequently used
least recently used
left recursive
length
level
lexical analysis
lexical scoping
LFU
lifetime
LIFO
linear congruential method
linear growth rate
linear index
linear order
linear probing
linear probing by steps
linear search
link node
linked list
linked stack
list
literal
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
matching
matching problem
max heap
maximal match
maximum lower bound
maximum match
MCST
measure of cost
member
member function
memory allocation
memory deallocation
memory hierarchy
memory leak
memory manager
memory pool
memory request
merge insert sort
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

natural numbers
necessary fallacy
neighbor
node
non-deterministic
non-deterministic algorithm
non-deterministic choice
non-deterministic polynomial time algorithm
non-strict partial order
non-terminal
NP
NP-Complete
NP-Completeness proof
NP-hard
nth roots of unity

O

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

P

page
parameter
parent
parent pointer representation
parity
parity bit
parse tree
parser
partial order
partially ordered set
partition
pass by reference
pass by value
path
path compression
PDA
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
primitive nth root of unity
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
production
production rule
program
promotion
proof
proof by contradiction
proof by induction
proving the contrapositive
pseudo polynomial
pseudo random
pseudo-random probing
push
pushdown automata

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
recursively enumerable
Red-Black Tree
reduction
reference
reference count algorithm
reference parameter
reflexive
Region Quadtree
regular language
relation
replacement selection
reserved block
resource constraints
root
rotation
rotational delay
rotational latency
run
run file
run-time polymorphism
runtime environment
runtime stack

S

scanner
scope
search key
search lower bound
search problem
search tree
search trie
searching
secondary clustering
secondary index
secondary key
secondary key index
secondary storage
sector
sector header
seed
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
signature file
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
solution space
solution tree
sorted list
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
start state
start symbol
state
State Machine
static
static scoping
Strassen's algorithm
strategy
stream
strict partial order
strong induction
subclass
subgraph
subset
subtract-and-guess
subtree
successful search
summation
superset
symbol table
symmetric
symmetric matrix
syntax analysis

T

tail
terminal
Theta notation
token
tombstone
topological sort
total order
total path length
Towers of Hanoi problem
track
track-to-track seek time
trailer node
transitive
transpose
trap state
traversal
tree
tree traversal
trie
truth table
tuple
Turing machine
Turing-acceptable
Turing-computable function
Turing-decidable
two-coloring
type

U

unary notation
uncountable
uncountably infinite
underflow
undirected edge
undirected graph
uninitialized
UNION
UNION/FIND
unit production
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

© Copyright 2016 by OpenDSA Project Contributors and distributed under an MIT license. Last updated on Mar 15, 2018. Created using Sphinx 1.2.
Close Window