Data Structures and Problem Solving Using Java

ISBN-10: 0201748355

ISBN-13: 9780201748352

Edition: 2nd 2002

Authors: Mark Allen Weiss

List price: $106.20 Buy it from $3.00
30 day, 100% satisfaction guarantee

If an item you ordered from TextbookRush does not meet your expectations due to an error on our part, simply fill out a return request and then return it by mail within 30 days of ordering it for a full refund of item cost.

Learn more about our returns policy


Data Structures and Problem Solving Using Java&&3/e& provides a practical introduction to data structures from a viewpoint of abstract thinking and problem solving, and incorporates the enhancements of Java 5.0.& It includes coverage of generic programming, and content on the design of generic collection classes. This book is appropriate for readers who are familiar with basic Java programming concepts or are new to the language and want to learn how it treats data structures concepts.
Used Starting from $3.00
what's this?
Rush Rewards U
Members Receive:
You have reached 400 XP and carrot coins. That is the daily max!
Study Briefs

Limited time offer: Get the first one free! (?)

All the information you need in one place! Each Study Brief is a summary of one specific subject; facts, figures, and explanations to help you learn faster.

Add to cart
Study Briefs
Periodic Table Online content $4.95 $1.99
Add to cart
Study Briefs
SQL Online content $4.95 $1.99
Add to cart
Study Briefs
MS Excel® 2010 Online content $4.95 $1.99
Add to cart
Study Briefs
MS Word® 2010 Online content $4.95 $1.99
Customers also bought

Book details

List price: $106.20
Edition: 2nd
Copyright year: 2002
Publisher: Addison-Wesley Longman, Incorporated
Publication date: 8/6/2001
Binding: Hardcover
Pages: 928
Size: 7.50" wide x 9.50" long x 1.50" tall
Weight: 3.718
Language: English

Tour Of Java
Primitive Java
The General Environment
The First Program
Primitive Types
Basic Operators
Conditional Statements
Reference Types
What Is a Reference
Basics of Objects and References
Exception Handling
Input and Output
Objects and Classes
What Is Object-oriented Programming?
A Simple Example
Basic Methods
Additional Constructs
A Design Pattern: Composite (Pair)
What Is Inheritance?
Designing Hierarchies
Multiple Inheritance
The Interface
Fundamental Inheritance in Java
Implementing Generic Components
The Functor (Function Objects)
Dynamic Binding Details
Algorithms And Building Blocks
Algorithm Analysis
What Is Algorithm Analysis?
Examples of Algorithm Running Times
The Maximum Contiguous Subsequence Sum Problem
General Big-Oh Rules
The Logarithm
Static Searching Problem
Checking an Algorithm Analysis
Limitations of Big-Oh Analysis
The Collections API
The Iterator Pattern
Collections API: Containers and Iterators
Generic Algorithms
The List Interface
Stacks and Queues
Priority Queues
What Is Recursion?
Background: Proofs by Mathematical Induction
Basic Recursion
Numerical Applications
Divide-and-Conquer Algorithms
Dynamic Programming
Backtracking Algorithms
Sorting Algorithms
Why Is Sorting Important?
Analysis of the Insertion Sort and Other Simple Sorts
A Lower Bound for Sorting
Why Do We Need Random Numbers?
Random-number Generators
Nonuniform Random Numbers
Generating a Random Permutation
Randomized Algorithms
Randomized Primality Testing
Fun and Games
Word Search Puzzles
The Game of Tic-Tac-Toe
Stacks and Compilers
Balanced-Symbol Checker
A Simple Calculator
File Compression
A Cross-reference Generator
The Josephus Problem
Event-driven Simulation
Graphs and Paths
Unweighted Shortest-path Problem
Positive-weighted, Shortest-path Problem
Negative-weighted, Shortest-path Problem
Path Problems in Acyclic Graphs
Inner Classes and ArrayList Implementation
Iterators and Nested Classes
Iterators and Inner Classes
The AbstractCollection Class
Implementation of ArrayList with an Iterator
Stacks and Queues
Dynamic Array Implementations
Linked-list Implementations
Comparison of the Two Methods
The java.util.Stack Class
Double-Ended Queues
Linked Lists
Basic Ideas
Java Implementation
Doubly Linked Lists and Circular Linked Lists
Sorted Linked Lists
Implementing the Collections API LinkedList Class
General Trees
Binary Trees
Recursion and Trees
Tree Traversal: Iterator Classes
Binary Search Trees
Basic Ideas
Order Statistics
Analysis of Binary Search Tree Operations
AVL Trees
Red-Black Trees
Implementing the Collections API TreeSet and TreeMap Classes
Hash Tables
Basic Ideas
Hash Function
Linear Probing
Quadratic Probing
Separate Chaining Hashing
Hash Tables Versus Binary Search Trees
Hashing Applications
A Priority Queue: The Binary Heap
Basic Ideas
Implementation of the Basic Operations
The buildHeap Operation: Linear-Time Heap Construction
Advanced Operations: decreaseKey and merge
Internal Sorting: Heapsort
External Sorting
Advanced Data Structures
Splay Trees
Self-Adjustment and Amortized Analysis
The Basic Bottom-Up Splay Tree
Basic Splay Tree Operations
Analysis of Bottom-Up Splaying
Top-Down Splay Trees
Implementation of Top-Down Splay Trees
Comparison of the Splay Tree with Other Search Trees
Merging Priority Queues
The Skew Heap
The Pairing Heap
The Disjoint Set Class
Equivalence Relations
Dynamic Equivalence and Two Applications
The Quick-Find Algorithm
The Quick-Union Algorithm
Java Implementation
Worst Case for Union-by-Rank and Path Compression
Graphical User Interfaces
Free shipping on orders over $35*

*A minimum purchase of $35 is required. Shipping is provided via FedEx SmartPost® and FedEx Express Saver®. Average delivery time is 1 – 5 business days, but is not guaranteed in that timeframe. Also allow 1 - 2 days for processing. Free shipping is eligible only in the continental United States and excludes Hawaii, Alaska and Puerto Rico. FedEx service marks used by permission."Marketplace" orders are not eligible for free or discounted shipping.

Learn more about the TextbookRush Marketplace.