Data Structures and Algorithms with Object-Oriented Design Patterns in Java (Worldwide Series in Computer Science)
Data Structures and Algorithms with Object-Oriented Design Patterns in Java (Worldwide Series in Computer Science)
ISBN: 0471346136
EAN: 2147483647
EAN: 2147483647
Year: 1999
Pages: 100
Pages: 100
Authors: Bruno R. Preiss
- No Title Found _Reports ask_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-01 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-01 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 AssistantsCo-op Students
- UW Undergraduate Research Assistants
- ECE499 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
Data Structures and Algorithms with Object-Oriented Design Patterns in Java (Worldwide Series in Computer Science)
ISBN: 0471346136
EAN: 2147483647
EAN: 2147483647
Year: 1999
Pages: 100
Pages: 100
Authors: Bruno R. Preiss