Register

OpenDSA Modules Collection with Slides

| 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
agile methods
algorithm
algorithm analysis
alias
all-pairs shortest paths problem
allocated
allocation
alphabet

alphabet trie
amortized analysis
amortized cost
ancestor
antisymmetric
approximation algorithm
arm
array
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
bad reference
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, [1]
bintree
bit vector
bitmap
block
Boolean expression
Boolean variable
boom
bounding box
branch-and-bounds algorithm
breadth-first search
break-even point
BST
bubble sort
Bubble Sort
bucket
bucket hashing
bucket sort
buddy method
buffer
buffer passing
buffer pool
buffering

C

caching
call stack
Carl Friedrich Gauss
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, [1]
collision resolution policy
comparable, [1]
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

data member

data structure

selecting

deallocated

deallocation

decision problem

decision tree

delegation mental model for recursion

dense graph

depth-first search

depth-first search tree

dereference

deserialization

design pattern

deterministic

deterministic algorithm

Deterministic Finite Acceptor

Deterministic Finite Automata

diagonalization argument

dictionary search

E

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

G

garbage
garbage collection
Gauss
general tree
grammar

graph
greedy algorithm
growth rate
guess-and-test
guided traversal

H

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, [1], [2]
instance variable
integer function

inter-sector gap
interface
intermediate code
intermediate code generation
internal fragmentation
internal node
internal sort
interpolation
interpolation search
interpreter
inversion, [1]
inverted file
inverted list
irreflexive
ISAM
iterator

J

job

jump search

K

K-ary tree
k-path
kd tree
key, [1], [2]
key sort

key space
key-space decomposition
key-value pair
knapsack problem
Kruskal's algorithm

L

labeled graph
language
Las Vegas algorithms
leaf node
least frequently used
least recently used
least squares regression
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
locality of reference
logarithm, [1]
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, [1]
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

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 queue

probabilistic algorithm

probabilistic data structure

probe function

probe sequence

problem instance

problem lower bound

problem upper bound

procedural programming paradigm

process

software development

production rule

proof, [1]

by contradiction
by induction
direct

proof by contradiction

proof by induction

proving the contrapositive

pseudo polynomial

pseudo random

pseudo-random probing

pushdown automata

Q

quadratic growth rate
quadratic probing
quadtree

queue
Quicksort, [1]

R

random access

random access memory

random permutation

randomized algorithm

range query

read/write head

rebalancing operation

record comparison

searching
sorting

recurrence relation

recurrence with full history

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

search key, [1], [2]

search lower bound

search problem

search tree

search trie

record comparison

secondary clustering

secondary index

secondary key

secondary key index

secondary storage

sector header

Selection Sort, [1]

selection sort

self-organizing list

self-organizing list heuristic

separate chaining

sequential access

sequential fit

sequential search

sequential tree representation

serialization

set product

shallow copy

Shellsort, [1]

increment

shifting method

shortest path

signature file

simple cycle

simple path

simple type

simulating recursion

single rotation

single-source shortest paths problem

singly linked list

snowplow argument

software engineering

software reuse

solution space

solution tree

sorted list

sorting

empirical comparison
exchange
lower bounds proof
record comparison

sorting lower bound

sorting problem

space/time tradeoff

sparse graph

sparse matrix

spatial application

spatial attribute

spatial data

spatial data structure

stack frame

stack variable

stale pointer

start state

start symbol

State Machine

static scoping

Strassen's algorithm

strict partial order

strong induction

subtract-and-guess

successful search

symbol table

symmetric matrix

syntax analysis

T

U

unary notation

uncountable

uncountably infinite

undirected edge

undirected graph

unified modeling langauage

selecting, [1]

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

Contact Us || Privacy | | License Contents