Data Structures And Algorithms With Object-Oriented Design Patterns In Java

• • *** No Title Found *** _Reports\task_page_thumbs.htm
  • WebZIP Tasks
  • WebZIP Task Summary
• • Copyright Notice
  • CV and Resume
  • Website of Bruno R. Preiss
  • Bruno's Home Page
  • Opuses (Opera?)
  • Contents
  • Journal Articles
  • From Design Patterns to Parallel Architecture Skeletons
  • Effects of the Checkpoint Interval on Time and Space in Time Warp
  • Optimal Memory Management for Time Warp Parallel Simulation
  • Simulating Continuous Systems with Piecewise-Linear Signals Using Time Warp
  • Short Packet Transfer Performance in Local Area Ring Networks
  • A Nonuniform Detector Aperture for CT
  • On the Transport of Charged Particles Through Spongy Materials
  • Conference Papers
  • Building Parallel Applications using Design Patterns
  • Research
  • Using Object-Oriented Techniques for Realizing Parallel Architectural Skeletons
  • Issues in Joint Undergraduate Software Engineering Degree Program Design
  • Architectural Skeletons: The Re-Usable Building-Blocks for Parallel Applications
  • Design Patterns for the Data Structures and Algorithms Course
  • The Parsimony Project: A Distributed Simulation Testbed in Java
  • Memory Management Techniques for Time Warp on a Distributed Memory Machine
  • An Algorithm for Speculative Parallel Execution of Rendezvous-Synchronized Simulation
  • On the Performance of a Multi-Threaded RISC Architecture
  • Selecting the Checkpoint Interval in Time Warp Parallel Simulation
  • A Unifying Framework for Distributed Routing Algorithms
  • Publications
  • On the Trade-Off between Time and Space in Optimistic Parallel Discrete-Event Simulation
  • Parallel Instance Discrete-Event Simulation Using a Vector Uniprocessor
  • Multi-Threaded Pipelining in a RISC Processor
  • Null Message Cancellation in Conservative Distributed Simulation
  • Performance of Discrete Event Simulation on a Multiprocessor Using Optimistic and Conservative Synchronization
  • The Impact of Lookahead on the Performance of Conservative Distributed Simulation
  • The Role of Knowledge in Distributed Simulation
  • The Yaddes Distributed Discrete Event Simulation Specification Language and Execution Environments
  • A Unified Modeling Methodology for Performance Evaluation of Distributed Discrete Event Simulation Mechanisms
  • Semi-Static Dataflow
  • Books
  • A Cache-based Message Passing Scheme for a Shared-bus Multiprocessor
  • Data Flow on a Queue Machine
  • Short-Packet Transfer Performance in Local Area Rings
  • Patents
  • Method, System and Apparatus For Provisioning Services to Subscribers in a Telecommunications Network
  • Interactive Voice Response System and Method
  • Telecommunication Architecture
  • Strategy for Negotiation of Telecommunication Resources
  • Method and System for Configuring Communication Resources
  • Technical Reports
  • Data Structures and Algorithms with Object-Oriented Design Patterns in C#
  • Transputer System User Guide-Second Edition
  • Effects of the Checkpoint Interval on Time and Space in Time Warp
  • Transputer System User Guide
  • YADDES-Yet Another Distributed Discrete Event Simulator: User Manual
  • Prediction and Lookahead in Distributed Simulation
  • The Yaddes Distributed Discrete Event Simulation Specification Language and Execution Environments
  • A Unified Modeling Methodology for Performance Evaluation of Distributed Discrete Event Simulation Mechanisms
  • Semi-static Dataflow
  • A Cache-based Message Passing Scheme for a Shared-bus Multiprocessor
  • Theses
  • Data Structures and Algorithms with Object-Oriented Design Patterns in Java
  • Data Flow on a Queue Machine
  • Design and Simulation of a Data-Flow Multiprocessor
  • LARNS: A Powerful Model and Software Package for the Simulation of Local Area Ring Networks
  • Unpublished Manuscripts
  • A Template-based Model for Developing Parallel Applications on a Network Cluster
  • A Pattern-Based Model for Developing Parallel Applications Using a Network of Processors
  • A Skeleton-Based Model for Developing Parallel Applications Using a Network of Processors
  • An Attributed, Time-Delayed Rendezvous Model for Parallel Discrete Event Simulation
  • Dynamic Rescheduling of Tasks for the Macro-Dataflow Paradigm
  • Ynot Logic Simulator: A Literate C++ Program
  • Solutions Manual: Data Structures and Algorithms with Object-Oriented Design Patterns in Java
  • A Time-Delayed-Rendezvous Model for Parallel Discrete Event Simulation
  • A New Model for Parallel Discrete Event Simulation
  • Parallel Simulation and Lotos: Research In Progress
  • Hobbes: A Multi-Threaded Superscalar Architecture
  • Dynamic Checkpoint Interval Selection in Time Warp Simulation
  • Yaddes-Yet Another Distributed Discrete Event Simulator
  • Queue Machines
  • Effective Memory Bandwidth of Band-Connected Partial Crossbars
  • An Occam Compiler for a Dataflow Multiprocessor (Extended Abstract)
  • Presentations
  • Solutions Manual: Data Structures and Algorithms with Object-Oriented Design Patterns in C++
  • Opuses (Opera?)
  • Personal
  • Home Address
  • CV and Resume
  • References
  • Data Structures and Algorithms with Object-Oriented Design Patterns in C++
  • Personal
  • Research
  • Bruno R. Preiss-Signature Page
  • Bruno's Home Page
  • • 404 Not Found
    • 404 Not Found
    • • Copyright Notice
      • Data Structures and Algorithms with Object-Oriented Design Patterns in Java
      • Bruno R. Preiss-Signature Page
      • • Data Structures and Algorithms with Object-Oriented Design Patterns in Java
        • Footnotes
        • Colophon
        • Introduction
        • LinkedList Constructor
        • purge Method
        • Accessor Methods
        • getFirst and getLast Methods
        • prepend Method
        • append Method
        • assign Method
        • extract Method
        • insertAfter and insertBefore Methods
        • Exercises
        • What This Book Is About
        • Projects
        • Data Types and Abstraction
        • Abstract Data Types
        • Design Patterns
        • Class Hierarchy
        • Java Objects and the Comparable Interface
        • Abstract Comparable Objects
        • Wrappers for the Primitive Types
        • Containers
        • Abstract Containers
        • Object-Oriented Design
        • Visitors
        • The isDone Method
        • Abstract Visitors
        • The AbstractContainer Class toString Method
        • Enumerations
        • Searchable Containers
        • Abstract Searchable Containers
        • Associations
        • Exercises
        • Projects
        • Abstraction
        • Stacks, Queues, and Deques
        • Stacks
        • Array Implementation
        • Fields
        • Constructor and purge Methods
        • push, pop, and getTop Methods
        • accept Method
        • getEnumeration Method
        • Linked-List Implementation
        • Fields
        • Encapsulation
        • Constructor and purge Methods
        • push, pop, and getTop Methods
        • accept Method
        • getEnumeration Method
        • Applications
        • Evaluating Postfix Expressions
        • Implementation
        • Queues
        • Array Implementation
        • Fields
        • Object Hierarchies and Design Patterns
        • Constructor and purge Methods
        • getHead, enqueue, and dequeue Methods
        • Linked-List Implementation
        • Fields
        • Constructor and purge Methods
        • getHead, enqueue, and dequeue Methods
        • Applications
        • Implementation
        • Deques
        • Array Implementation
        • Containers
        • The ``Head'' Methods
        • The ``Tail'' Methods
        • Linked List Implementation
        • The ``Head'' Methods
        • The ``Tail'' Methods
        • Doubly-Linked and Circular Lists
        • Exercises
        • Projects
        • Ordered Lists and Sorted Lists
        • Ordered Lists
        • Enumerations
        • Array Implementation
        • Fields
        • Creating a List and Inserting Items
        • Finding Items in a List
        • Removing Items from a List
        • Positions of Items in a List
        • Finding the Position of an Item and Accessing by Position
        • Inserting an Item at an Arbitrary Position
        • Removing Arbitrary Items by Position
        • Linked-List Implementation
        • Visitors
        • Fields
        • Inserting and Accessing Items in a List
        • Finding Items in a List
        • Removing Items from a List
        • Positions of Items in a List
        • Finding the Position of an Item and Accessing by Position
        • Inserting an Item at an Arbitrary Position
        • Removing Arbitrary Items by Position
        • Performance Comparison: OrderedListAsArray vs. ListAsLinkedList
        • Applications
        • Cursors
        • Sorted Lists
        • Array Implementation
        • Inserting Items in a Sorted List
        • Locating Items in an Array-Binary Search
        • Finding Items in a Sorted List
        • Removing Items from a List
        • Linked-List Implementation
        • Inserting Items in a Sorted List
        • Other Operations on Sorted Lists
        • Performance Comparison: SortedListAsArray vs. SortedListAsList
        • Dedication
        • Adapters
        • Applications
        • Implementation
        • Analysis
        • Exercises
        • Projects
        • Hashing, Hash Tables, and Scatter Tables
        • Hashing-The Basic Idea
        • Example
        • Keys and Hash Functions
        • Avoiding Collisions
        • Singletons
        • Spreading Keys Evenly
        • Ease of Computation
        • Hashing Methods
        • Division Method
        • Middle Square Method
        • Multiplication Method
        • Fibonacci Hashing
        • Hash Function Implementations
        • Integral Keys
        • Floating-Point Keys
        • The Features of Java You Need to Know
        • Character String Keys
        • Hashing Containers
        • Using Associations
        • Hash Tables
        • Abstract Hash Tables
        • Separate Chaining
        • Implementation
        • Constructor, getLength and purge Methods
        • Inserting and Removing Items
        • Finding an Item
        • Variables
        • Average Case Analysis
        • Scatter Tables
        • Chained Scatter Table
        • Implementation
        • Constructor, getLength, and purge Methods
        • Inserting and Finding an Item
        • Removing Items
        • Worst-Case Running Time
        • Average Case Analysis
        • Scatter Table using Open Addressing
        • Primitive Types and Reference Types
        • Linear Probing
        • Quadratic Probing
        • Double Hashing
        • Implementation
        • Constructor, getLength, and purge Methods
        • Inserting Items
        • Finding Items
        • Removing Items
        • Average Case Analysis
        • Applications
        • Parameter Passing
        • Exercises
        • Projects
        • Trees
        • Basics
        • Terminology
        • More Terminology
        • Alternate Representations for Trees
        • N-ary Trees
        • Binary Trees
        • Tree Traversals
        • Classes and Objects
        • Preorder Traversal
        • Postorder Traversal
        • Inorder Traversal
        • Breadth-First Traversal
        • Expression Trees
        • Infix Notation
        • Prefix Notation
        • Postfix Notation
        • Implementing Trees
        • Tree Traversals
        • Inheritance
        • Depth-First Traversal
        • Preorder, Inorder, and Postorder Traversals
        • Breadth-First Traversal
        • accept Method
        • Tree Enumerations
        • Constructor
        • hasMoreElements and nextElement Methods
        • General Trees
        • Fields
        • Constructor and purge Methods
        • Interfaces and Polymorphism
        • getKey and getSubtree Methods
        • attachSubtree and detachSubtree Methods
        • N-ary Trees
        • Fields
        • Constructors
        • isEmpty Method
        • getKey, attachKey, and detachKey Methods
        • getSubtree, attachSubtree and detachSubtree Methods
        • Binary Trees
        • Fields
        • Other Features
        • Constructors
        • purge Method
        • Binary Tree Traversals
        • Comparing Trees
        • Applications
        • Implementation
        • Exercises
        • Projects
        • Search Trees
        • Basics
        • Preface
        • How This Book Is Organized
        • M-Way Search Trees
        • Binary Search Trees
        • Searching a Search Tree
        • Searching an M-way Tree
        • Searching a Binary Tree
        • Average Case Analysis
        • Successful Search
        • Solving The Recurrence-Telescoping
        • Unsuccessful Search
        • Traversing a Search Tree
        • Models and Asymptotic Analysis
        • Implementing Search Trees
        • Binary Search Trees
        • Fields
        • find Method
        • findMin Method
        • Inserting Items in a Binary Search Tree
        • insert and attachKey Methods
        • Removing Items from a Binary Search Tree
        • withdraw Method
        • AVL Search Trees
        • Foundational Data Structures
        • Implementing AVL Trees
        • Constructor
        • getHeight, adjustHeight, and getBalanceFactor Methods
        • Inserting Items into an AVL Tree
        • Balancing AVL Trees
        • Single Rotations
        • Double Rotations
        • Implementation
        • Removing Items from an AVL Tree
        • M-Way Search Trees
        • Abstract Data Types and the Class Hierarchy
        • Implementing M-Way Search Trees
        • Implementation
        • Constructor and getM Methods
        • Inorder Traversal
        • Finding Items in an M-Way Search Tree
        • Linear Search
        • Binary Search
        • Inserting Items into an M-Way Search Tree
        • Removing Items from an M-Way Search Tree
        • B-Trees
        • Data Structures
        • Implementing B-Trees
        • Fields
        • Constructor and attachSubtree Methods
        • Inserting Items into a B-Tree
        • Implementation
        • Running Time Analysis
        • Removing Items from a B-Tree
        • Applications
        • Exercises
        • Projects
        • Algorithms
        • Heaps and Priority Queues
        • Basics
        • Binary Heaps
        • Complete Trees
        • Complete N-ary Trees
        • Implementation
        • Fields
        • Constructor and purge Methods
        • Putting Items into a Binary Heap
        • Removing Items from a Binary Heap
        • Algorithm Analysis
        • Leftist Heaps
        • Leftist Trees
        • Implementation
        • Fields
        • Merging Leftist Heaps
        • Putting Items into a Leftist Heap
        • Removing Items from a Leftist Heap
        • Binomial Queues
        • Binomial Trees
        • Binomial Queues
        • A Detailed Model of the Computer
        • Implementation
        • Heap-Ordered Binomial Trees
        • Adding Binomial Trees
        • Binomial Queues
        • Fields
        • addTree and removeTree
        • findMinTree and findMin Methods
        • Merging Binomial Queues
        • Putting Items into a Binomial Queue
        • Removing an Item from a Binomial Queue
        • The Basic Axioms
        • Applications
        • Discrete Event Simulation
        • Implementation
        • Exercises
        • Projects
        • Sets, Multisets, and Partitions
        • Basics
        • Implementing Sets
        • Array and Bit-Vector Sets
        • Basic Operations
        • A Simple Example-Arithmetic Series Summation
        • Union, Intersection, and Difference
        • Comparing Sets
        • Bit-Vector Sets
        • Basic Operations
        • Union, Intersection, and Difference
        • Multisets
        • Array Implementation
        • Basic Operations
        • Union, Intersection, and Difference
        • Linked-List Implementation
        • Goals
        • Array Subscripting Operations
        • Union
        • Intersection
        • Partitions
        • Representing Partitions
        • Implementing a Partition using a Forest
        • Implementation
        • Constructor
        • find and join Methods
        • Collapsing Find
        • Union by Size
        • Another Example-Horner's Rule
        • Union by Height or Rank
        • Applications
        • Exercises
        • Projects
        • Garbage Collection and the Other Kind of Heap
        • What is Garbage?
        • Reduce, Reuse, Recycle
        • Reduce
        • Reuse
        • Recycle
        • Analyzing Recursive Methods
        • Helping the Garbage Collector
        • Reference Counting Garbage Collection
        • When Objects Refer to Other Objects
        • Why Reference Counting Does Not Work
        • Mark-and-Sweep Garbage Collection
        • The Fragmentation Problem
        • Stop-and-Copy Garbage Collection
        • The Copy Algorithm
        • Mark-and-Compact Garbage Collection
        • Handles
        • Solving Recurrence Relations-Repeated Substitution
        • Exercises
        • Projects
        • Algorithmic Patterns and Problem Solvers
        • Brute-Force and Greedy Algorithms
        • Example-Counting Change
        • Brute-Force Algorithm
        • Greedy Algorithm
        • Example-0/1 Knapsack Problem
        • Backtracking Algorithms
        • Example-Balancing Scales
        • Yet Another Example-Finding the Largest Element of an Array
        • Representing the Solution Space
        • Abstract Backtracking Solvers
        • Abstract Solvers
        • Depth-First Solver
        • Breadth-First Solver
        • Branch-and-Bound Solvers
        • Depth-First, Branch-and-Bound Solver
        • Example-0/1 Knapsack Problem Again
        • Top-Down Algorithms: Divide-and-Conquer
        • Example-Binary Search
        • Average Running Times
        • Example-Computing Fibonacci Numbers
        • Example-Merge Sorting
        • Running Time of Divide-and-Conquer Algorithms
        • Case 1 (#tex2html_wrap_inline67543#)
        • Case 2 (#tex2html_wrap_inline67557#)
        • Case 3 (#tex2html_wrap_inline67567#)
        • Summary
        • Example-Matrix Multiplication
        • Bottom-Up Algorithms: Dynamic Programming
        • Example-Generalized Fibonacci Numbers
        • About Harmonic Numbers
        • Example-Computing Binomial Coefficients
        • Application: Typesetting Problem
        • Example
        • Implementation
        • Randomized Algorithms
        • Generating Random Numbers
        • The Minimal Standard Random Number Generator
        • Implementation
        • Random Variables
        • A Simple Random Variable
        • Best-Case and Worst-Case Running Times
        • Uniformly Distributed Random Variables
        • Exponentially Distributed Random Variables
        • Monte Carlo Methods
        • Example-Computing #tex2html_wrap_inline68195#
        • Simulated Annealing
        • Example-Balancing Scales
        • Exercises
        • Projects
        • Sorting Algorithms and Sorters
        • Basics
        • The Last Axiom
        • Sorting and Sorters
        • Abstract Sorters
        • Sorter Class Hierarchy
        • Insertion Sorting
        • Straight Insertion Sort
        • Implementation
        • Average Running Time
        • Binary Insertion Sort
        • Exchange Sorting
        • Bubble Sort
        • A Simplified Model of the Computer
        • Quicksort
        • Implementation
        • Running Time Analysis
        • Worst-Case Running Time
        • Best-Case Running Time
        • Average Running Time
        • Selecting the Pivot
        • Selection Sorting
        • Straight Selection Sorting
        • Implementation
        • Approach
        • An Example-Geometric Series Summation
        • Sorting with a Heap
        • Implementation
        • Building the Heap
        • Running Time Analysis
        • The Sorting Phase
        • Merge Sorting
        • Implementation
        • Merging
        • Two-Way Merge Sorting
        • Running Time Analysis
        • About Arithmetic Series Summation
        • A Lower Bound on Sorting
        • Distribution Sorting
        • Bucket Sort
        • Implementation
        • Radix Sort
        • Implementation
        • Performance Data
        • Exercises
        • Projects
        • Graphs and Graph Algorithms
        • Example-Geometric Series Summation Again
        • Basics
        • Directed Graphs
        • Terminology
        • More Terminology
        • Directed Acyclic Graphs
        • Undirected Graphs
        • Terminology
        • Labeled Graphs
        • Representing Graphs
        • Adjacency Matrices
        • About Geometric Series Summation
        • Sparse vs. Dense Graphs
        • Adjacency Lists
        • Implementing Graphs
        • Vertices
        • Enumerations
        • Edges
        • Graphs and Digraphs
        • Accessors and Mutators
        • Enumerations
        • Graph Traversals
        • Example-Computing Powers
        • Directed Graphs
        • Abstract Graphs
        • Implementing Undirected Graphs
        • Using Adjacency Matrices
        • Using Adjacency Lists
        • Comparison of Graph Representations
        • Space Comparison
        • Time Comparison
        • Graph Traversals
        • Depth-First Traversal
        • Example-Geometric Series Summation Yet Again
        • Implementation
        • Running Time Analysis
        • Breadth-First Traversal
        • Implementation
        • Running Time Analysis
        • Topological Sort
        • Implementation
        • Running Time Analysis
        • Graph Traversal Applications: Testing for Cycles and Connectedness
        • Connectedness of an Undirected Graph
        • Exercises
        • Connectedness of a Directed Graph
        • Testing Strong Connectedness
        • Testing for Cycles in a Directed Graph
        • Shortest-Path Algorithms
        • Single-Source Shortest Path
        • Dijkstra's Algorithm
        • Data Structures for Dijkstra's Algorithm
        • Implementation
        • Running Time Analysis
        • All-Pairs Source Shortest Path
        • Projects
        • Floyd's Algorithm
        • Implementation
        • Running Time Analysis
        • Minimum-Cost Spanning Trees
        • Constructing Spanning Trees
        • Minimum-Cost Spanning Trees
        • Prim's Algorithm
        • Implementation
        • Kruskal's Algorithm
        • Implementation
        • Asymptotic Notation
        • Running Time Analysis
        • Application: Critical Path Analysis
        • Implementation
        • Exercises
        • Projects
        • Java and Object-Oriented Programming
        • Variables
        • Primitive Types
        • References Types
        • Null References
        • An Asymptotic Upper Bound-Big Oh
        • Parameter Passing
        • Passing Primitive Types
        • Passing Reference Types
        • Objects and Classes
        • Class Members: Fields and Methods
        • Constructors
        • The No-Arg Constructor
        • Accessors and Mutators
        • Mutators
        • Member Access Control
        • Outline
        • A Simple Example
        • Inner Classes
        • Static Inner Classes
        • Non-Static Inner Classes
        • Inheritance and Polymorphism
        • Derivation and Inheritance
        • Derivation and Access Control
        • Polymorphism
        • Interfaces
        • Abstract Methods and Abstract Classes
        • Method Resolution
        • Big Oh Fallacies and Pitfalls
        • Abstract Classes and Concrete Classes
        • Algorithmic Abstraction
        • Multiple Inheritance
        • Run-Time Type Information and Casts
        • Exceptions
        • Class Hierarchy Diagrams
        • Character Codes
        • References
        • Index
        • Properties of Big Oh
        • About Polynomials
        • About Logarithms
        • Tight Big Oh Bounds
        • More Big Oh Fallacies and Pitfalls
        • Conventions for Writing Big Oh Expressions
        • An Asymptotic Lower Bound-Omega
        • A Simple Example
        • Suggested Course Outline
        • About Polynomials Again
        • More Notation-Theta and Little Oh
        • Asymptotic Analysis of Algorithms
        • Rules For Big Oh Analysis of Running Time
        • Example-Prefix Sums
        • Example-Fibonacci Numbers
        • Example-Bucket Sort
        • Reality Check
        • Checking Your Analysis
        • Exercises
        • Online Course Materials
        • Projects
        • Foundational Data Structures
        • Arrays
        • Extending Java Arrays
        • Constructors
        • assign Method
        • Accessor Methods
        • Array Indexing Methods-get and put
        • Resizing an Array-setBase and setLength
        • Multi-Dimensional Arrays
        • Contents
        • Array Subscript Calculations
        • An Implementation
        • Constructor
        • Array Indexing Methods-get and put
        • Matrices
        • Dense Matrices
        • Canonical Matrix Multiplication
        • Singly-Linked Lists
        • An Implementation
        • List Elements
  • • • • Bruno Richard Preiss: Curriculum Vita
        • Degrees
        • Patents
        • Books
        • Conference Papers (full paper refereed)
        • Conference Papers (abstract refereed)
        • Submitted Conference Papers
        • Technical Reports
        • Theses
        • Presentations, Seminars, Invited Talks
        • Research Grants
        • Teaching Record
        • Diplomas
        • Supervision of Students
        • Graduate Students
        • NSERC Undergraduate Summer Research Assistants/Co-op Students
        • UW Undergraduate Research Assistants
        • E&CE 499 Projects
        • Graduate Student Theses Supervised
        • Service to the University of Waterloo
        • Service to the Profession
        • Scholarships and Awards
        • Employment record
        • Membership in Professional Organizations and Societies
        • Publications
        • Refereed Full Journal Papers
        • Submitted Journal Papers
        • Refereed Technical Notes
    • resume

• *** No Title Found *** _Reports\task_page_thumbs.htm
• 404 Not Found
• 404 Not Found
• A Cache-based Message Passing Scheme for a Shared-bus Multiprocessor
• A Cache-based Message Passing Scheme for a Shared-bus Multiprocessor
• A Detailed Model of the Computer
• A Lower Bound on Sorting
• A New Model for Parallel Discrete Event Simulation
• A Nonuniform Detector Aperture for CT
• A Pattern-Based Model for Developing Parallel Applications Using a Network of Processors
• A Simple Example
• A Simple Example
• A Simple Example-Arithmetic Series Summation
• A Simple Random Variable
• A Simplified Model of the Computer
• A Skeleton-Based Model for Developing Parallel Applications Using a Network of Processors
• A Template-based Model for Developing Parallel Applications on a Network Cluster
• A Time-Delayed-Rendezvous Model for Parallel Discrete Event Simulation
• A Unified Modeling Methodology for Performance Evaluation of Distributed Discrete Event Simulation Mechanisms
• A Unified Modeling Methodology for Performance Evaluation of Distributed Discrete Event Simulation Mechanisms
• A Unifying Framework for Distributed Routing Algorithms
• About Arithmetic Series Summation
• About Geometric Series Summation
• About Harmonic Numbers
• About Logarithms
• About Polynomials
• About Polynomials Again
• Abstract Backtracking Solvers
• Abstract Classes and Concrete Classes
• Abstract Comparable Objects
• Abstract Containers
• Abstract Data Types
• Abstract Data Types and the Class Hierarchy
• Abstract Graphs
• Abstract Hash Tables
• Abstract Methods and Abstract Classes
• Abstract Searchable Containers
• Abstract Solvers
• Abstract Sorters
• Abstract Visitors
• Abstraction
• accept Method
• accept Method
• accept Method
• Accessor Methods
• Accessor Methods
• Accessors and Mutators
• Accessors and Mutators
• Adapters
• Adding Binomial Trees
• addTree and removeTree
• Adjacency Lists
• Adjacency Matrices
• Algorithm Analysis
• Algorithmic Abstraction
• Algorithmic Patterns and Problem Solvers
• Algorithms
• All-Pairs Source Shortest Path
• Alternate Representations for Trees
• An Algorithm for Speculative Parallel Execution of Rendezvous-Synchronized Simulation
• An Asymptotic Lower Bound-Omega
• An Asymptotic Upper Bound-Big Oh
• An Attributed, Time-Delayed Rendezvous Model for Parallel Discrete Event Simulation
• An Example-Geometric Series Summation
• An Implementation
• An Implementation
• An Occam Compiler for a Dataflow Multiprocessor (Extended Abstract)
• Analysis
• Analyzing Recursive Methods
• Another Example-Horner's Rule
• append Method
• Application: Critical Path Analysis
• Application: Typesetting Problem
• Applications
• Applications
• Applications
• Applications
• Applications
• Applications
• Applications
• Applications
• Applications
• Approach
• Architectural Skeletons: The Re-Usable Building-Blocks for Parallel Applications
• Array and Bit-Vector Sets
• Array Implementation
• Array Implementation
• Array Implementation
• Array Implementation
• Array Implementation
• Array Implementation
• Array Indexing Methods-get and put
• Array Indexing Methods-get and put
• Array Subscript Calculations
• Array Subscripting Operations
• Arrays
• assign Method
• assign Method
• Associations
• Asymptotic Analysis of Algorithms
• Asymptotic Notation
• attachSubtree and detachSubtree Methods
• Average Case Analysis
• Average Case Analysis
• Average Case Analysis
• Average Case Analysis
• Average Running Time
• Average Running Time
• Average Running Times
• AVL Search Trees
• Avoiding Collisions
• Backtracking Algorithms
• Balancing AVL Trees
• Basic Operations
• Basic Operations
• Basic Operations
• Basics
• Basics
• Basics
• Basics
• Basics
• Basics
• Best-Case and Worst-Case Running Times
• Best-Case Running Time
• Big Oh Fallacies and Pitfalls
• Binary Heaps
• Binary Insertion Sort
• Binary Search
• Binary Search Trees
• Binary Search Trees
• Binary Tree Traversals
• Binary Trees
• Binary Trees
• Binomial Queues
• Binomial Queues
• Binomial Queues
• Binomial Trees
• Bit-Vector Sets
• Books
• Books
• Bottom-Up Algorithms: Dynamic Programming
• Branch-and-Bound Solvers
• Breadth-First Solver
• Breadth-First Traversal
• Breadth-First Traversal
• Breadth-First Traversal
• Bruno R. Preiss-Signature Page
• Bruno R. Preiss-Signature Page
• Bruno Richard Preiss: Curriculum Vita
• Bruno's Home Page
• Bruno's Home Page
• Brute-Force Algorithm
• Brute-Force and Greedy Algorithms
• B-Trees
• Bubble Sort
• Bucket Sort
• Building Parallel Applications using Design Patterns
• Building the Heap
• Canonical Matrix Multiplication
• Case 1 (#tex2html_wrap_inline67543#)
• Case 2 (#tex2html_wrap_inline67557#)
• Case 3 (#tex2html_wrap_inline67567#)
• Chained Scatter Table
• Character Codes
• Character String Keys
• Checking Your Analysis
• Class Hierarchy
• Class Hierarchy Diagrams
• Class Members: Fields and Methods
• Classes and Objects
• Collapsing Find
• Colophon
• Comparing Sets
• Comparing Trees
• Comparison of Graph Representations
• Complete N-ary Trees
• Complete Trees
• Conference Papers
• Conference Papers (abstract refereed)
• Conference Papers (full paper refereed)
• Connectedness of a Directed Graph
• Connectedness of an Undirected Graph
• Constructing Spanning Trees
• Constructor
• Constructor
• Constructor
• Constructor
• Constructor and attachSubtree Methods
• Constructor and getM Methods
• Constructor and purge Methods
• Constructor and purge Methods
• Constructor and purge Methods
• Constructor and purge Methods
• Constructor and purge Methods
• Constructor and purge Methods
• Constructor, getLength and purge Methods
• Constructor, getLength, and purge Methods
• Constructor, getLength, and purge Methods
• Constructors
• Constructors
• Constructors
• Constructors
• Containers
• Containers
• Contents
• Contents
• Conventions for Writing Big Oh Expressions
• Copyright Notice
• Copyright Notice
• Creating a List and Inserting Items
• Cursors
• CV and Resume
• CV and Resume
• Data Flow on a Queue Machine
• Data Flow on a Queue Machine
• Data Structures
• Data Structures and Algorithms with Object-Oriented Design Patterns in C#
• Data Structures and Algorithms with Object-Oriented Design Patterns in C++
• Data Structures and Algorithms with Object-Oriented Design Patterns in Java
• Data Structures and Algorithms with Object-Oriented Design Patterns in Java
• Data Structures and Algorithms with Object-Oriented Design Patterns in Java
• Data Structures for Dijkstra's Algorithm
• Data Types and Abstraction
• Dedication
• Degrees
• Dense Matrices
• Depth-First Solver
• Depth-First Traversal
• Depth-First Traversal
• Depth-First, Branch-and-Bound Solver
• Deques
• Derivation and Access Control
• Derivation and Inheritance
• Design and Simulation of a Data-Flow Multiprocessor
• Design Patterns
• Design Patterns for the Data Structures and Algorithms Course
• Dijkstra's Algorithm
• Diplomas
• Directed Acyclic Graphs
• Directed Graphs
• Directed Graphs
• Discrete Event Simulation
• Distribution Sorting
• Division Method
• Double Hashing
• Double Rotations
• Doubly-Linked and Circular Lists
• Dynamic Checkpoint Interval Selection in Time Warp Simulation
• Dynamic Rescheduling of Tasks for the Macro-Dataflow Paradigm
• E&CE 499 Projects
• Ease of Computation
• Edges
• Effective Memory Bandwidth of Band-Connected Partial Crossbars
• Effects of the Checkpoint Interval on Time and Space in Time Warp
• Effects of the Checkpoint Interval on Time and Space in Time Warp
• Employment record
• Encapsulation
• Enumerations
• Enumerations
• Enumerations
• Enumerations
• Evaluating Postfix Expressions
• Example
• Example
• Example-0/1 Knapsack Problem
• Example-0/1 Knapsack Problem Again
• Example-Balancing Scales
• Example-Balancing Scales
• Example-Binary Search
• Example-Bucket Sort
• Example-Computing #tex2html_wrap_inline68195#
• Example-Computing Binomial Coefficients
• Example-Computing Fibonacci Numbers
• Example-Computing Powers
• Example-Counting Change
• Example-Fibonacci Numbers
• Example-Generalized Fibonacci Numbers
• Example-Geometric Series Summation Again
• Example-Geometric Series Summation Yet Again
• Example-Matrix Multiplication
• Example-Merge Sorting
• Example-Prefix Sums
• Exceptions
• Exchange Sorting
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exercises
• Exponentially Distributed Random Variables
• Expression Trees
• Extending Java Arrays
• extract Method
• Fibonacci Hashing
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• Fields
• find and join Methods
• find Method
• Finding an Item
• Finding Items
• Finding Items in a List
• Finding Items in a List
• Finding Items in a Sorted List
• Finding Items in an M-Way Search Tree
• Finding the Position of an Item and Accessing by Position
• Finding the Position of an Item and Accessing by Position
• findMin Method
• findMinTree and findMin Methods
• Floating-Point Keys
• Floyd's Algorithm
• Footnotes
• Foundational Data Structures
• Foundational Data Structures
• From Design Patterns to Parallel Architecture Skeletons
• Garbage Collection and the Other Kind of Heap
• General Trees
• Generating Random Numbers
• getEnumeration Method
• getEnumeration Method
• getFirst and getLast Methods
• getHead, enqueue, and dequeue Methods
• getHead, enqueue, and dequeue Methods
• getHeight, adjustHeight, and getBalanceFactor Methods
• getKey and getSubtree Methods
• getKey, attachKey, and detachKey Methods
• getSubtree, attachSubtree and detachSubtree Methods
• Goals
• Graduate Student Theses Supervised
• Graduate Students
• Graph Traversal Applications: Testing for Cycles and Connectedness
• Graph Traversals
• Graph Traversals
• Graphs and Digraphs
• Graphs and Graph Algorithms
• Greedy Algorithm
• Handles
• Hash Function Implementations
• Hash Tables
• Hashing Containers
• Hashing Methods
• Hashing, Hash Tables, and Scatter Tables
• Hashing-The Basic Idea
• hasMoreElements and nextElement Methods
• Heap-Ordered Binomial Trees
• Heaps and Priority Queues
• Helping the Garbage Collector
• Hobbes: A Multi-Threaded Superscalar Architecture
• Home Address
• How This Book Is Organized
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementation
• Implementing a Partition using a Forest
• Implementing AVL Trees
• Implementing B-Trees
• Implementing Graphs
• Implementing M-Way Search Trees
• Implementing Search Trees
• Implementing Sets
• Implementing Trees
• Implementing Undirected Graphs
• Index
• Infix Notation
• Inheritance
• Inheritance and Polymorphism
• Inner Classes
• Inorder Traversal
• Inorder Traversal
• insert and attachKey Methods
• insertAfter and insertBefore Methods
• Inserting an Item at an Arbitrary Position
• Inserting an Item at an Arbitrary Position
• Inserting and Accessing Items in a List
• Inserting and Finding an Item
• Inserting and Removing Items
• Inserting Items
• Inserting Items in a Binary Search Tree
• Inserting Items in a Sorted List
• Inserting Items in a Sorted List
• Inserting Items into a B-Tree
• Inserting Items into an AVL Tree
• Inserting Items into an M-Way Search Tree
• Insertion Sorting
• Integral Keys
• Interactive Voice Response System and Method
• Interfaces
• Interfaces and Polymorphism
• Intersection
• Introduction
• isEmpty Method
• Issues in Joint Undergraduate Software Engineering Degree Program Design
• Java and Object-Oriented Programming
• Java Objects and the Comparable Interface
• Journal Articles
• Keys and Hash Functions
• Kruskal's Algorithm
• Labeled Graphs
• LARNS: A Powerful Model and Software Package for the Simulation of Local Area Ring Networks
• Leftist Heaps
• Leftist Trees
• Linear Probing
• Linear Search
• Linked List Implementation
• LinkedList Constructor
• Linked-List Implementation
• Linked-List Implementation
• Linked-List Implementation
• Linked-List Implementation
• Linked-List Implementation
• List Elements
• Locating Items in an Array-Binary Search
• Mark-and-Compact Garbage Collection
• Mark-and-Sweep Garbage Collection
• Matrices
• Member Access Control
• Membership in Professional Organizations and Societies
• Memory Management Techniques for Time Warp on a Distributed Memory Machine
• Merge Sorting
• Merging
• Merging Binomial Queues
• Merging Leftist Heaps
• Method and System for Configuring Communication Resources
• Method Resolution
• Method, System and Apparatus For Provisioning Services to Subscribers in a Telecommunications Network
• Middle Square Method
• Minimum-Cost Spanning Trees
• Minimum-Cost Spanning Trees
• Models and Asymptotic Analysis
• Monte Carlo Methods
• More Big Oh Fallacies and Pitfalls
• More Notation-Theta and Little Oh
• More Terminology
• More Terminology
• Multi-Dimensional Arrays
• Multiple Inheritance
• Multiplication Method
• Multisets
• Multi-Threaded Pipelining in a RISC Processor
• Mutators
• M-Way Search Trees
• M-Way Search Trees
• N-ary Trees
• N-ary Trees
• Non-Static Inner Classes
• NSERC Undergraduate Summer Research Assistants/Co-op Students
• Null Message Cancellation in Conservative Distributed Simulation
• Null References
• Object Hierarchies and Design Patterns
• Object-Oriented Design
• Objects and Classes
• On the Performance of a Multi-Threaded RISC Architecture
• On the Trade-Off between Time and Space in Optimistic Parallel Discrete-Event Simulation
• On the Transport of Charged Particles Through Spongy Materials
• Online Course Materials
• Optimal Memory Management for Time Warp Parallel Simulation
• Opuses (Opera?)
• Opuses (Opera?)
• Ordered Lists
• Ordered Lists and Sorted Lists
• Other Features
• Other Operations on Sorted Lists
• Outline
• Parallel Instance Discrete-Event Simulation Using a Vector Uniprocessor
• Parallel Simulation and Lotos: Research In Progress
• Parameter Passing
• Parameter Passing
• Partitions
• Passing Primitive Types
• Passing Reference Types
• Patents
• Patents
• Performance Comparison: OrderedListAsArray vs. ListAsLinkedList
• Performance Comparison: SortedListAsArray vs. SortedListAsList
• Performance Data
• Performance of Discrete Event Simulation on a Multiprocessor Using Optimistic and Conservative Synchronization
• Personal
• Personal
• Polymorphism
• Positions of Items in a List
• Positions of Items in a List
• Postfix Notation
• Postorder Traversal
• Prediction and Lookahead in Distributed Simulation
• Preface
• Prefix Notation
• Preorder Traversal
• Preorder, Inorder, and Postorder Traversals
• prepend Method
• Presentations
• Presentations, Seminars, Invited Talks
• Primitive Types
• Primitive Types and Reference Types
• Prim's Algorithm
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Projects
• Properties of Big Oh
• Publications
• Publications
• purge Method
• purge Method
• push, pop, and getTop Methods
• push, pop, and getTop Methods
• Putting Items into a Binary Heap
• Putting Items into a Binomial Queue
• Putting Items into a Leftist Heap
• Quadratic Probing
• Queue Machines
• Queues
• Quicksort
• Radix Sort
• Random Variables
• Randomized Algorithms
• Reality Check
• Recycle
• Reduce
• Reduce, Reuse, Recycle
• Refereed Full Journal Papers
• Refereed Technical Notes
• Reference Counting Garbage Collection
• References
• References
• References Types
• Removing an Item from a Binomial Queue
• Removing Arbitrary Items by Position
• Removing Arbitrary Items by Position
• Removing Items
• Removing Items
• Removing Items from a Binary Heap
• Removing Items from a Binary Search Tree
• Removing Items from a B-Tree
• Removing Items from a Leftist Heap
• Removing Items from a List
• Removing Items from a List
• Removing Items from a List
• Removing Items from an AVL Tree
• Removing Items from an M-Way Search Tree
• Representing Graphs
• Representing Partitions
• Representing the Solution Space
• Research
• Research
• Research Grants
• Resizing an Array-setBase and setLength
• resume
• Reuse
• Rules For Big Oh Analysis of Running Time
• Running Time Analysis
• Running Time Analysis
• Running Time Analysis
• Running Time Analysis
• Running Time Analysis
• Running Time Analysis
• Running Time Analysis
• Running Time Analysis
• Running Time Analysis
• Running Time Analysis
• Running Time of Divide-and-Conquer Algorithms
• Run-Time Type Information and Casts
• Scatter Table using Open Addressing
• Scatter Tables
• Scholarships and Awards
• Search Trees
• Searchable Containers
• Searching a Binary Tree
• Searching a Search Tree
• Searching an M-way Tree
• Selecting the Checkpoint Interval in Time Warp Parallel Simulation
• Selecting the Pivot
• Selection Sorting
• Semi-Static Dataflow
• Semi-static Dataflow
• Separate Chaining
• Service to the Profession
• Service to the University of Waterloo
• Sets, Multisets, and Partitions
• Short Packet Transfer Performance in Local Area Ring Networks
• Shortest-Path Algorithms
• Short-Packet Transfer Performance in Local Area Rings
• Simulated Annealing
• Simulating Continuous Systems with Piecewise-Linear Signals Using Time Warp
• Single Rotations
• Single-Source Shortest Path
• Singletons
• Singly-Linked Lists
• Solutions Manual: Data Structures and Algorithms with Object-Oriented Design Patterns in C++
• Solutions Manual: Data Structures and Algorithms with Object-Oriented Design Patterns in Java
• Solving Recurrence Relations-Repeated Substitution
• Solving The Recurrence-Telescoping
• Sorted Lists
• Sorter Class Hierarchy
• Sorting Algorithms and Sorters
• Sorting and Sorters
• Sorting with a Heap
• Space Comparison
• Sparse vs. Dense Graphs
• Spreading Keys Evenly
• Stacks
• Stacks, Queues, and Deques
• Static Inner Classes
• Stop-and-Copy Garbage Collection
• Straight Insertion Sort
• Straight Selection Sorting
• Strategy for Negotiation of Telecommunication Resources
• Submitted Conference Papers
• Submitted Journal Papers
• Successful Search
• Suggested Course Outline
• Summary
• Supervision of Students
• Teaching Record
• Technical Reports
• Technical Reports
• Telecommunication Architecture
• Terminology
• Terminology
• Terminology
• Testing for Cycles in a Directed Graph
• Testing Strong Connectedness
• The ``Head'' Methods
• The ``Head'' Methods
• The ``Tail'' Methods
• The ``Tail'' Methods
• The AbstractContainer Class toString Method
• The Basic Axioms
• The Copy Algorithm
• The Features of Java You Need to Know
• The Fragmentation Problem
• The Impact of Lookahead on the Performance of Conservative Distributed Simulation
• The isDone Method
• The Last Axiom
• The Minimal Standard Random Number Generator
• The No-Arg Constructor
• The Parsimony Project: A Distributed Simulation Testbed in Java
• The Role of Knowledge in Distributed Simulation
• The Sorting Phase
• The Yaddes Distributed Discrete Event Simulation Specification Language and Execution Environments
• The Yaddes Distributed Discrete Event Simulation Specification Language and Execution Environments
• Theses
• Theses
• Tight Big Oh Bounds
• Time Comparison
• Top-Down Algorithms: Divide-and-Conquer
• Topological Sort
• Transputer System User Guide
• Transputer System User Guide-Second Edition
• Traversing a Search Tree
• Tree Enumerations
• Tree Traversals
• Tree Traversals
• Trees
• Two-Way Merge Sorting
• Undirected Graphs
• Uniformly Distributed Random Variables
• Union
• Union by Height or Rank
• Union by Size
• Union, Intersection, and Difference
• Union, Intersection, and Difference
• Union, Intersection, and Difference
• Unpublished Manuscripts
• Unsuccessful Search
• Using Adjacency Lists
• Using Adjacency Matrices
• Using Associations
• Using Object-Oriented Techniques for Realizing Parallel Architectural Skeletons
• UW Undergraduate Research Assistants
• Variables
• Variables
• Vertices
• Visitors
• Visitors
• Website of Bruno R. Preiss
• WebZIP Task Summary
• WebZIP Tasks
• What is Garbage?
• What This Book Is About
• When Objects Refer to Other Objects
• Why Reference Counting Does Not Work
• withdraw Method
• Worst-Case Running Time
• Worst-Case Running Time
• Wrappers for the Primitive Types
• Yaddes-Yet Another Distributed Discrete Event Simulator
• YADDES-Yet Another Distributed Discrete Event Simulator: User Manual
• Yet Another Example-Finding the Largest Element of an Array
• Ynot Logic Simulator: A Literate C++ Program