Date Structures and Algorithm Analysis in C

ISBN-10: 0201498405

ISBN-13: 9780201498400

Edition: 2nd 1997 (Revised)

Authors: Mark A. Weiss

List price: $176.00 Buy it from $4.50
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:

In this second EDITION of his best-selling book, Data Structures and Algorithm Analysis in C, Mark Allen Weiss, continues to refine and enhance his innovative approach to algorithms and data structures. Using a C implementation, he highlights conceptual topics, focusing on ADTs and the analysis of algorithms for efficiency as well as performance and running time. Dr. Weiss also distinguishes Data Structures and Algorithm Analysis in C with the extensive use of figures and examples showing the successive stages of an algorithm, his engaging writing style, and a logical organization of topics. Features bull; bull; Includes a chapter on algorithm and design techniques that covers greedy algorithms, divide and conquer algorithms, dynamic programming, randomized algorithms, and backtracking bull; Presents current topics and newer data structures such as Fibonacci heaps, skew heaps, binomial queues, skip lists, and splay trees bull; Contains a chapter on amortized analysis that examines the advanced data structures presented earlier in the book bull; Provides a new chapter on advanced data structures and their implementation covering red black trees, top down splay trees, treaps, k-d trees, pairing heaps, and more bull; Incorporates new results on the average case analysis of heapsort bull; Offers source code from example programs via anonymous FTP 0201498405B04062001
Used Starting from $105.20
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
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
Add to cart
Study Briefs
MS PowerPoint® 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: 2nd
Copyright year: 1997
Publisher: Addison Wesley
Publication date: 9/9/1996
Binding: Hardcover
Pages: 600
Size: 8.00" wide x 9.75" long x 1.50" tall
Weight: 2.442
Language: English

Introduction
What's the Book About?
Mathematics Review
Exponents
Logarithms
Series
Modular Arithmetic
The P word
A Brief Introduction to Recursion
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
Checking Your Analysis
A Grain of Salt
Lists, Stacks, and Queues
Abstract Data Types (ADTs)
The List ADT
Simple Array Implementation of Lists
Linked Lists
Programming Details
Common Errors
Doubly Linked Lists
Circularly Linked Lists
Examples
Cursor Implementation of Linked Lists
The Stack ADT
Stack Model
Implementation of Stacks
Applications
The Queue ADT
Queue Model
Array Implementation of Queues
Applications of Queues
Trees
Preliminaries
Implementation of Trees
Tree Traversals with an Application
Binary Trees
Implementation
Expression Trees
The Search Tree ADT—Binary Search Trees
MakeEmpty
Find
FindMin and FindMax
Insert
Delete
Average-Case Analysis
AVL Trees
Single Rotation
Double Rotation
Splay Trees
A Simple Idea (That Does Not Work)
Splaying
Tree Traversals (Revisited)
B-Trees
Hashing
General Idea
Hash Function
Separate Chaining
Open Addressing
Linear Probing
Quadratic Probing
Double Hashing
Rehashing
Extendible Hashing
Priority Queues (Heaps)
Model
Simple Implementations
Binary Heaps
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
Implementations of Binomial Queues
Sorting
Preliminaries
Insertion Sort
The Algorithm
Analysis of Insertion Sort
A Lower Bound for Simple Sorting Algorithms
Shellsort
Analysis of Insertion Sort
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
Sorting Large Structures
A General Lower Bound for Sorting
Decision Trees
Bucket Sort
External Sorting
Why We Need New Algorithms
Model for External Sorting
The Simple Algorithm
Multiway Merge
Polyphase Merge
Replacement Selection
The Disjoint Set ADT
Equivalence Relations
The Dynamic Equivalence Problem
Basic Data Structure
Smart Union Algorithms
Path Compression
Worst Case for Union-by-Rank and Path Compression
Analysis of the Union/Find Algorithm
An Application
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
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 the NP-Completeness
Easy vs. Hard
The Class NP
NP-Complete Problems
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
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
Advanced Data Structures and Implementation
Top-Down Splay Trees
Red Black Trees
Bottom-Up Insertion
Top-Down Red Black Trees
Top-Down Deletion
Deterministic Skip Lists
AA-Trees
Treaps
k-d Trees
Pairing Heaps
Index 0201498405T04062001<$$$>
×
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.

×