CART

(0) items

Data Structures And Algorithm Analysis in C++,9780321375315
This item qualifies for
FREE SHIPPING!

FREE SHIPPING OVER $59!

Your order must be $59 or more, you must select US Postal Service Shipping as your shipping preference, and the "Group my items into as few shipments as possible" option when you place your order.

Bulk sales, PO's, Marketplace Items, eBooks, Apparel, and DVDs not included.

Data Structures And Algorithm Analysis in C++

by
Edition:
3rd
ISBN13:

9780321375315

ISBN10:
0321375319
Format:
Paperback
Pub. Date:
1/1/2006
Publisher(s):
Addison Wesley
List Price: $107.40
More New and Used
from Private Sellers
Starting at $47.66
See Prices

Rent Textbook

We're Sorry
Sold Out

Used Textbook

We're Sorry
Sold Out

eTextbook

We're Sorry
Not Available

New Textbook

We're Sorry
Sold Out

Related Products


  • Data Structures and Algorithm Analysis in C++
    Data Structures and Algorithm Analysis in C++
  • Data Structures and Algorithm Analysis in C++
    Data Structures and Algorithm Analysis in C++
  • Data Structures and Algorithm Analysis in C++
    Data Structures and Algorithm Analysis in C++




Summary

Mark Allen Weiss innovative approach to algorithms and data structures teaches the simultaneous development of sound analytical and programming skills for the advanced data structures course. Readers learn how to reduce time constraints and develop programs efficiently by analyzing the feasibility of an algorithm before it is coded. The C++ language is brought up-to-date and simplified, and the Standard Template Library is now fully incorporated throughout the text. This Third Edition also features significantly revised coverage of lists, stacks, queues, and trees and an entire chapter dedicated to amortized analysis and advanced data structures such as the Fibonacci heap. Known for its clear and friendly writing style, Data Structures and Algorithm Analysis in C++ is logically organized to cover advanced data structures topics from binary heaps to sorting to NP-completeness. Figures and examples illustrating successive stages of algorithms contribute to Weiss careful, rigorous and in-depth analysis of each type of algorithm.

Table of Contents

Preface xv
Introduction
1(42)
What's the Book About?
1(1)
Mathematics Review
2(5)
Exponents
3(1)
Logarithms
3(1)
Series
4(1)
Modular Arithmetic
5(1)
The P Word
6(1)
A Brief Introduction to Recursion
7(4)
C++ Classes
11(8)
Basic class Syntax
12(1)
Extra Constructor Syntax and Accessors
12(3)
Separation of Interface and Implementation
15(2)
vector and string
17(2)
C++ Details
19(10)
Pointers
19(2)
Parameter Passing
21(1)
Return Passing
22(1)
Reference Variables
23(1)
The Big Three: Destructor, Copy Constructor, operator=
23(3)
C-style Arrays and Strings
26(3)
Templates
29(8)
Function Templates
29(1)
Class Templates
30(2)
Object, Comparable, and an Example
32(2)
Function Objects
34(1)
Separate Compilation of Class Templates
35(2)
Using Matrices
37(6)
The Data Members, Constructor, and Basic Accessors
37(1)
operator[ ]
37(2)
Destructor, Copy Assignment, Copy Constructor
39(1)
Summary
39(1)
Exercises
39(2)
References
41(2)
Algorithm Analysis
43(28)
Mathematical Background
43(3)
Model
46(1)
What to Analyze
46(3)
Running Time Calculations
49(22)
A Simple Example
49(1)
General Rules
50(2)
Solutions for the Maximum Subsequence Sum Problem
52(6)
Logarithms in the Running Time
58(4)
Checking Your Analysis
62(1)
A Grain of Salt
63(1)
Summary
63(1)
Exercises
64(5)
References
69(2)
Lists, Stacks, and Queues
71(42)
Abstract Data Types (ADTs)
71(1)
The List ADT
72(2)
Simple Array Implementation of Lists
72(1)
Simple Linked Lists
73(1)
vector and list in the STL
74(5)
Iterators
75(2)
Example: Using erase on a List
77(1)
const_iterators
77(2)
Implementation of vector
79(4)
Implementation of list
83(11)
The Stack ADT
94(10)
Stack Model
94(1)
Implementation of Stacks
95(1)
Applications
96(8)
The Queue ADT
104(9)
Queue Model
104(1)
Array Implementation of Queues
104(2)
Applications of Queues
106(1)
Summary
107(1)
Exercises
108(5)
Trees
113(72)
Preliminaries
113(6)
Implementation of Trees
114(1)
Tree Traversals with an Application
115(4)
Binary Trees
119(5)
Implementation
120(1)
An Example: Expression Trees
121(3)
The Search Tree ADT---Binary Search Trees
124(12)
contains
125(1)
findMin and findMax
125(4)
insert
129(1)
remove
130(2)
Destructor and Copy Assignment Operator
132(1)
Average-Case Analysis
133(3)
AVL Trees
136(13)
Single Rotation
139(3)
Double Rotation
142(7)
Splay Trees
149(9)
A Simple Idea (That Does Not Work)
150(2)
Splaying
152(6)
Tree Traversals (Revisited)
158(1)
B-Trees
159(6)
Sets and Maps in the Standard Library
165(20)
Sets
165(1)
Maps
166(1)
Implementation of set and map
167(1)
An Example That Uses Several Maps
168(6)
Summary
174(1)
Exercises
174(7)
References
181(4)
Hashing
185(28)
General Idea
185(1)
Hash Function
186(2)
Separate Chaining
188(4)
Hash Tables Without Linked Lists
192(8)
Linear Probing
193(2)
Quadratic Probing
195(4)
Double Hashing
199(1)
Rehashing
200(4)
Hash Tables in the Standard Library
204(1)
Extendible Hashing
204(9)
Summary
207(1)
Exercises
208(3)
References
211(2)
Priority Queues (Heaps)
213(48)
Model
213(1)
Simple Implementations
214(1)
Binary Heap
215(10)
Structure Property
215(1)
Heap-Order Property
216(1)
Basic Heap Operations
217(3)
Other Heap Operations
220(5)
Applications of Priority Queues
225(3)
The Selection Problem
226(1)
Event Simulation
227(1)
d-Heaps
228(1)
Leftist Heaps
229(6)
Leftist Heap Property
229(1)
Leftist Heap Operations
230(5)
Skew Heaps
235(4)
Binomial Queues
239(12)
Binomial Queue Structure
240(1)
Binomial Queue Operations
241(3)
Implementation of Binomial Queues
244(7)
Priority Queues in the Standard Library
251(10)
Summary
251(1)
Exercises
251(6)
References
257(4)
Sorting
261(54)
Preliminaries
261(1)
Insertion Sort
262(3)
The Algorithm
262(1)
STL Implementation of Insertion Sort
263(1)
Analysis of Insertion Sort
264(1)
A Lower Bound for Simple Sorting Algorithms
265(1)
Shellsort
266(4)
Worst-Case Analysis of Shellsort
268(2)
Heapsort
270(4)
Analysis of Heapsort
272(2)
Mergesort
274(5)
Analysis of Mergesort
276(3)
Quicksort
279(13)
Picking the Pivot
280(2)
Partitioning Strategy
282(2)
Small Arrays
284(1)
Actual Quicksort Routines
284(3)
Analysis of Quicksort
287(3)
A Linear-Expected-Time Algorithm for Selection
290(2)
Indirect Sorting
292(5)
vector<Comparable*> Does Not Work
295(1)
Smart Pointer Class
295(1)
Overloading operator<
295(1)
Dereferencing a Pointer with *
295(1)
Overloading the Type Conversion Operator
295(1)
Implicit Type Conversions Are Everywhere
296(1)
Dual-Direction Implicit Conversions Can Cause Ambiguities
296(1)
Pointer Subtraction Is Legal
297(1)
A General Lower Bound for Sorting
297(2)
Decision Trees
297(2)
Bucket Sort
299(1)
External Sorting
300(15)
Why We Need New Algorithms
300(1)
Model for External Sorting
300(1)
The Simple Algorithm
301(1)
Multiway Merge
302(1)
Polyphase Merge
303(1)
Replacement Selection
304(1)
Summary
305(1)
Exercises
306(5)
References
311(4)
The Disjoint Set Class
315(24)
Equivalence Relations
315(1)
The Dynamic Equivalence Problem
316(1)
Basic Data Structure
317(4)
Smart Union Algorithms
321(3)
Path Compression
324(1)
Worst Case for Union-by-Rank and Path Compression
325(6)
Analysis of the Union/Find Algorithm
326(5)
An Application
331(8)
Summary
334(1)
Exercises
335(1)
References
336(3)
Graph Algorithms
339(70)
Definitions
339(3)
Representation of Graphs
340(2)
Topological Sort
342(3)
Shortest-Path Algorithms
345(22)
Unweighted Shortest Paths
347(4)
Dijkstra's Algorithm
351(9)
Graphs with Negative Edge Costs
360(1)
Acyclic Graphs
360(4)
All-Pairs Shortest Path
364(1)
Shortest Path Example
365(2)
Network Flow Problems
367(5)
A Simple Maximum-Flow Algorithm
367(5)
Minimum Spanning Tree
372(6)
Prim's Algorithm
373(3)
Kruskal's Algorithm
376(2)
Applications of Depth-First Search
378(14)
Undirected Graphs
379(2)
Biconnectivity
381(4)
Euler Circuits
385(3)
Directed Graphs
388(2)
Finding Strong Components
390(2)
Introduction to NP-Completeness
392(17)
Easy vs. Hard
392(1)
The Class NP
393(1)
NP-Complete Problems
394(2)
Summary
396(1)
Exercises
396(8)
References
404(5)
Algorithm Design Techniques
409(82)
Greedy Algorithms
409(18)
A Simple Scheduling Problem
410(3)
Huffman Codes
413(6)
Approximate Bin Packing
419(8)
Divide and Conquer
427(15)
Running Time of Divide and Conquer Algorithms
428(2)
Closest-Points Problem
430(5)
The Selection Problem
435(3)
Theoretical Improvements for Arithmetic Problems
438(4)
Dynamic Programming
442(12)
Using a Table Instead of Recursion
442(2)
Ordering Matrix Multiplications
444(3)
Optimal Binary Search Tree
447(4)
All-Pairs Shortest Path
451(3)
Randomized Algorithms
454(10)
Random Number Generators
455(4)
Skip Lists
459(2)
Primality Testing
461(3)
Backtracking Algorithms
464(27)
The Turnpike Reconstruction Problem
465(4)
Games
469(6)
Summary
475(1)
Exercises
475(10)
References
485(6)
Amortized Analysis
491(26)
An Unrelated Puzzle
492(1)
Binomial Queues
492(5)
Skew Heaps
497(2)
Fibonacci Heaps
499(10)
Cutting Nodes in Leftist Heaps
500(2)
Lazy Merging for Binomial Queues
502(4)
The Fibonacci Heap Operations
506(1)
Proof of the Time Bound
506(3)
Splay Trees
509(8)
Summary
513(1)
Exercises
513(2)
References
515(2)
Advanced Data Structures and Implementation
517(50)
Top-Down Splay Trees
517(8)
Red-Black Trees
525(10)
Bottom-Up Insertion
526(1)
Top-Down Red-Black Trees
527(4)
Top-Down Deletion
531(4)
Deterministic Skip Lists
535(5)
AA-Trees
540(7)
Treaps
547(2)
k-d Trees
549(4)
Pairing Heaps
553(14)
Summary
558(1)
Exercises
558(5)
References
563(4)
Appendix A Separate Compilation of Class Templates
567(4)
Everything in the Header
568(1)
Explicit Instantiation
568(2)
The export Directive
570(1)
Index 571


Please wait while the item is added to your cart...