Data Structures and Algorithm Analysis in Java

ISBN-10: 0132576279

ISBN-13: 9780132576277

Edition: 3rd 2012 (Revised)

Authors: Mark A. Weiss
List price: $176.00 Buy it from $58.71 Rent it from $35.66
eBook available
This item qualifies for FREE shipping

*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.

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

Description: Data Structures and Algorithm Analysis in Java is an "advanced algorithms" book that fits between traditional CS2 and Algorithms Analysis courses. in the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amount of efficiency. Readers should have some knowledge of intermediate programming, including topics as object-based programming and recursion, and some background in discrete math. As the speed and power of computers increases, so does the need for effective programming and algorithm analysis. By approaching these skills in tandem, Mark Allen Weiss teaches readers to develop well-constructed, maximally efficient programs in Java. Weiss clearly explains topics from binary heaps to sorting to NP-completeness, and dedicates a full chapter to amortized analysis and advanced data structures and their implementation. Figures and examples illustrating successive stages of algorithms contribute to Weiss' careful, rigorous and in-depth analysis of each type of algorithm. A logical organization of topics and full access to source code complement the text's coverage.

Used Starting from $115.13
New Starting from $187.57
Rent Starting from $35.66
eBooks Starting from $34.99
Rent
Buy
what's this?
Rush Rewards U
Members Receive:
coins
coins
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

Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading

Book details

List price: $176.00
Edition: 3rd
Copyright year: 2012
Publisher: Addison Wesley
Publication date: 11/18/2011
Binding: Hardcover
Pages: 640
Size: 7.75" wide x 9.50" long x 1.00" tall
Weight: 3.080
Language: English

Introduction
What's the Book About?
Mathematics Review
Exponents
Logarithms
Series
Modular Arithmetic
The P Word
A Brief Introduction to Recursion
Implementing Generic Components Pre-Java 5
Using Object for Genericity
Wrappers for Primitive Types
Using Interface Types for Genericity
Compatibility of Array Types
Implementing Generic Components Using Java 5 Generics
Simple Generic Classes and Interfaces
Autoboxing/Unboxing
The Diamond Operator
Wildcards with Bounds
Generic Static Methods
Type Bounds
Type Erasure
Restrictions on Generics
Function Objects
Summary
Exercises
References
Algorithm Analysis
Mathematical Background
Model
What to Analyze
Running Time Calculations
A Simple Example
General Rules
Solutions for the Maximum Subsequence Sum Problem
Logarithms in the Running Time
A Grain of Salt
Summary
Exercises
References
Lists, Stacks, and Queues
Abstract Data Types (ADTs)
The List ADT
Simple Array Implementation of Lists
Simple Linked Lists
Lists in the Java Collections API
Collection Interface
Iterators
The List Interface, ArrayList, and LinkedList
Example: Using remove on a LinkedList
ListIterators
Implementation of ArrayList
The Basic Class
The Iterator and Java Nested and Inner Classes
Implementation of LinkedList
The Stack ADT
Stack Model
Implementation of Stacks
Applications
The Queue ADT
Queue Model
Array Implementation of Queues
Applications of Queues
Summary
Exercises
Trees
Preliminaries
Implementation of Trees
Tree Traversals with an Application
Binary Trees
Implementation
An Example: Expression Trees
The Search Tree ADT-Binary Search Trees
contains
findMin and findMax
insert
remove
Average-Case Analysis
AVL Trees
Single Rotation
Double Rotation
Splay Trees
A Simple Idea (That Does Not Work)
Splaying
Tree Traversals (Revisited)
B-Trees
Sets and Maps in the Standard Library
Sets
Maps
Implementation of TreeSet and TreeMap
An Example That Uses Several Maps
Summary
Exercises
References
Hashing
General Idea
Hash Function
Separate Chaining
Hash Tables Without Linked Lists
Linear Probing
Quadratic Probing
Double Hashing
Rehashing
Hash Tables in the Standard Library
Hash Tables with Worst-Case O(1) Access
Perfect Hashing
Cuckoo Hashing
Hopscotch Hashing
Universal Hashing
Extendible Hashing
Summary
Exercises
References
Priority Queues (Heaps)
Model
Simple Implementations
Binary Heap
Structure Property
Heap-Order Property
Basic Heap Operations
Other Heap Operations
Applications of Priority Queues
The Selection Problem
Event Simulation
d-Heaps
Leftist Heaps
Leftist Heap Property
Leftist Heap Operations
Skew Heaps
Binomial Queues
Binomial Queue Structure
Binomial Queue Operations
Implementation of Binomial Queues
Priority Queues in the Standard Library
Summary
Exercises
References
Sorting
Preliminaries
Insertion Sort
The Algorithm
Analysis of Insertion Sort
A Lower Bound for Simple Sorting Algorithms
Shellsort
Worst-Case Analysis of Shellsort
Heapsort
Analysis of Heapsort
Mergesort
Analysis of Mergesort
Quicksort
Picking the Pivot
Partitioning Strategy
Small Arrays
Actual Quicksort Routines
Analysis of Quicksort
A Linear-Expected-Time Algorithm for Selection
A General Lower Bound for Sorting
Decision Trees
Decision-Tree Lower Bounds for Selection Problems
Adversary Lower Bounds
Linear-Time Sorts: Bucket Sort and Radix Sort
External Sorting
Why We Need New Algorithms
Model for External Sorting
The Simple Algorithm
Multiway Merge
Polyphase Merge
Replacement Selection
Summary
Exercises
References
The Disjoint Set Class
Equivalence Relations
The Dynamic Equivalence Problem
Basic Data Structure
Smart Union Algorithms
Path Compression
Worst Case for Union-by-Rank and Path Compression
Slowly Growing Functions
An Analysis By Recursive Decomposition
An O(M log * N) Bound
An O(M � (M, N)) Bound
An Application
Summary
Exercises
References
Graph Algorithms
Definitions
Representation of Graphs
Topological Sort
Shortest-Path Algorithms
Unweighted Shortest Paths
Dijkstra's Algorithm
Graphs with Negative Edge Costs
Acyclic Graphs
All-Pairs Shortest Path
Shortest-Path Example
Network Flow Problems
A Simple Maximum-Flow Algorithm
Minimum Spanning Tree
Prim's Algorithm
Kruskal's Algorithm
Applications of Depth-First Search
Undirected Graphs
Biconnectivity
Euler Circuits
Directed Graphs
Finding Strong Components
Introduction to NP-Completeness
Easy vs. Hard
The Class NP
NP-Complete Problems
Summary
Exercises
References
Algorithm Design
Techniques
Greedy Algorithms
A Simple Scheduling Problem
Huffman Codes
Approximate Bin Packing
Divide and Conquer
Running Time of Divide-and-Conquer Algorithms
Closest-Points Problem
The Selection Problem
Theoretical Improvements for Arithmetic Problems
Dynamic Programming
Using a Table Instead of Recursion
Ordering Matrix Multiplications
Optimal Binary Search Tree
All-Pairs Shortest Path
Randomized Algorithms
Random Number Generators
Skip Lists
Primality Testing
Backtracking Algorithms
The Turnpike Reconstruction Problem
Games
Summary
Exercises
References
Amortized Analysis
An Unrelated Puzzle
Binomial Queues
Skew Heaps
Fibonacci Heaps
Cutting Nodes in Leftist Heaps
Lazy Merging for Binomial Queues
The Fibonacci Heap Operations
Proof of the Time Bound
Splay Trees
Summary
×
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.

×