Index

Up: Data Structures Previous: Generic arrays

Index

abstract class

Abstract classes to Abstract classes

adjacency list

Adjacency lists to Adjacency lists

adjacency matrix

Adjacency matrix to Adjacency matrix

array

Arrays to Array Access and Memory

as parameter: Arrays as Parameters
assignment: Assignment
bounds: Array Bounds
copying: Assignment
equality: Equality
expansion: Implementation to Implementation
initialisation: Initialisation of Array Variables to Initialisation of Both Together
length: Length
multi-dimensional: Multi-Dimensional Arrays
variables: Array Variables

balanced trees

Binary Search Trees | remove

binary heap

Binary Heaps and Priority to Arithmetic of Tree Traversal

arithmetic of tree traversal: Arithmetic of Tree Traversal
array representation: Array Representation
definition: Complete Binary Trees
deletion: Removal Algorithm to Code for remove
insertion: Insertion Algorithm to Code for add
strict: Strict Priority Queues to Strict Priority Queues

binary search

for integer arrays: Binary search
generic: The Comparable Interface

binary search tree

Binary Search Trees to Code and demonstration

abstract SearchTree class

The abstract SearchTree class to The abstract SearchTree class

implementation: EmptyTree and NodeTree implementations to The toString method

definition

Binary Search Trees

deletion

remove

EmptyTree class

Empty trees and node to Discussion

enumeration

see traversal

insertion

add

NodeTree class

Empty trees and node to Discussion

toString method

The toString method

traversal

Enumerations to elementsInOrder for the NodeTree

in order: elementsInOrder for the NodeTree to elementsInOrder for the NodeTree
level order: elementsLevelOrder for the NodeTree to elementsLevelOrder for the NodeTree

binary tree

complete

Complete Binary Trees to Complete Binary Trees

array as: Arrays as complete binary

definition

Binary Search Trees

vs. binary search tree

Binary Search Trees

bounds of array

Array Bounds

clustering

primary: Clustering
secondary: Clustering

collision resolution

Collision resolution

Comparable

implementation: Doing it yourself to Doing it yourself
interface: The Comparable Interface to The Comparable Interface
vs. equals: Doing it yourself

Dijkstra's algorithm

Dijkstra's algorithm to Shortest paths

efficiency

Efficiency

implementation of

Java implementation

use of priority queue: The basic algorithm

justification

Justification to Comment.

directed graph

Weighted Graphs

double hashing

Double hashing to Performance

Enumeration

Enumerations and Iterators to Extensions of the Iterator

interface: Enumerations to Enumerations

enumerator

see Enumeration

equality

array: Equality
linked list: Equality

exceptions

Note on Exceptions to Note on Exceptions

expansion of arrays

Implementation to Implementation

fail-fast iterator

Fail-fast Iteration

generics

Generics in Java 5

bounds on types: Bounds on types
boxing and unboxing: Boxing and unboxing
enhanced for: The Iterable interface and
generic arrays: Generic arrays
generic types: Generic types
wildcards: Wildcards

graph

acyclic

arc

connected

directed

edge

see arc

node

Weighted Graphs

path

Paths and lengths

path length

Paths and lengths

representation

adjacency list: Adjacency lists to Adjacency lists
adjacency matrix: Adjacency matrix to Adjacency matrix

undirected

Weighted Graphs

vertex

see node

weighted

see weighted graph

hash function

Hashing

hash table

Hash Tables to Code and demonstration

abstract ProbingHashTable class

Implementation to The iterator

access in constant time

Hashing

clustering

primary: Clustering
secondary: Clustering

collision resolution

double hashing: Double hashing to Performance
linear probing: Collision resolution to Clustering
quadratic probing: Quadratic probing to Clustering
separate chaining: Separate chaining

DoubleHashingTable class

The findIndex method to The findIndex method

findIndex method

The findIndex method

hash code

Hashing

hash function

Hashing | Choice of hash function

Boolean: The Boolean hash function
Integer: The Integer hash function
Object: The Object hash function
String: The String hash function

iterator

The iterator to The iterator

load factor

Load factor

primality of table length

Success | Double hashing | Instance variables and the

QuadraticProbingTable class

The findIndex method to The findIndex method

heap sort

Heap Sort to Code and demonstration

restoring heap order: Building the heap to Efficiency
sorting by removal: Sorting by removal to Sorting by removal

inner class

Enumeration to Enumeration

interfaces

Comparable: The Comparable Interface to The Comparable Interface
PriorityQueue: Priority Queues
Enumeration: Enumerations to Enumerations
Iterator: Iterators to Iterators
LookupTable: Lookup tables to Lookup tables
Queue: Interface
Stack: Interfaces

iteration

see Iterator

Iterator

Enumerations and Iterators to Extensions of the Iterator

fail-fast: Fail-fast Iteration
interface: Iterators to Iterators
semantics of remove: Iterators

linear probing

Collision resolution to Clustering

linked list

The Stack as a to List Implementation of Queue | Linked Lists to Code and demonstration

deletion: Deletion
equality: Equality to Equality
header node: Iteration to The header node.
insertion: Insertion
iterator: Iteration to The header node.
reversal: Reversing a list
toString method: The toString method

list

see linked list

ListNode

The ListNode | Instance variables and the

load factor

Load factor

LookupTable

hash table implementation: Implementation to Code and demonstration
interface: Lookup tables to Lookup tables

memory allocation

Array Access and Memory

multi-dimensional array

see array

open addressing

Collision resolution

order

Order to Doing it yourself

priority queue

Priority Queues to Code and Demonstration

implementation by binary heap: Implementation of Priority Queues to Strict Priority Queues
interface: Priority Queues
strict: Strict Priority Queues to Strict Priority Queues

quadratic probing

Quadratic probing to Clustering

queue

Queues to Code and Demonstration

implementation

array: Implementation to Implementation
list: List Implementation of Queue to List Implementation of Queue

interface

Interface

priority

see priority queue

reversal of list

Reversing a list

search tree

see binary search tree

searching

binary search: Binary search to Generic methods
use of order: Order

separate chaining

Separate chaining

shortest paths

see weighted graph, shortest paths

sorting

heap sort: Heap Sort to Code and demonstration
in place: Heap Sort | Sorting by removal

stack

Stacks to Code and Demonstration

implementation

array: Implementation to Implementation
list: List Implementation of Stack to List Implementation of Stack

interface

Interfaces

tree

see binary search tree

version

of weighted graph: Version number

weighted graph

Weighted Graphs to Code

file input

File input and output

generalised

The nature of weights to The nature of weights

implementation

Arc class: The arcs iterator
Node class: The Node class
nodeMap container: The nodeMap container
Tip class: The Node class
WeightedGraph class: The WeightedGraph constructor
arc insertion: Arc insertion to Arc insertion
arc removal: The arcs iterator
iterators: Iterators to The arcs iterator
version: Version number
workspace: Workspace | Workspace | Efficiency

shortest paths

Shortest Paths in Weighted to The code

enumeration of: Enumerations of shortest paths
methods: Shortest path methods to Efficiency

workspace

of node in positive weighted graph: Workspace | Efficiency
of node in weighted graph: Workspace

Peter Williams 2005-06-07