Algorithms in C++

by
Edition: 1st
Format: Hardcover
Pub. Date: 1992-01-01
Publisher(s): Addison-Wesley Professional
List Price: $64.99

Rent Book

Select for Price
There was a problem. Please try again later.

New Book

We're Sorry
Sold Out

Used Book

We're Sorry
Sold Out

eBook

We're Sorry
Not Available

How Marketplace Works:

  • This item is offered by an independent seller and not shipped from our warehouse
  • Item details like edition and cover design may differ from our description; see seller's comments before ordering.
  • Sellers much confirm and ship within two business days; otherwise, the order will be cancelled and refunded.
  • Marketplace purchases cannot be returned to eCampus.com. Contact the seller directly for inquiries; if no response within two days, contact customer service.
  • Additional shipping costs apply to Marketplace purchases. Review shipping costs at checkout.

Summary

This version of Sedgewick's bestselling book provides a comprehensive collection of algorithms implemented in C++. The algorithms included cover a broad range of fundamental and more advanced methods: sorting, searching, string processing, geometric, graph, and mathematical algorithms. Readers will discover-in an object-oriented programming environment-how key algorithms can be implemented, run, debugged, and used in real applications.

Table of Contents

Fundamentals 3(90)
1. Introduction Algorithms. Outline of Topics.
3(4)
2. C++ (and C) Example: Euclid's Algorithm. Types of Data. Input/Output. Concluding Remarks.
7(8)
3. Elementary Data Structures Arrays. Linked Lists. Storage Allocation. Pushdown Stacks. Queues. Linked List Implementation of Stacks. Abstract and Concrete Data Types.
15(20)
4. Trees Glossary. Properties. Representing Binary Trees. Representing Forests. Traversing Trees.
35(16)
5. Recursion Recurrences. Divide-and-Conquer. Recursive Tree Traversal. Removing Recursion. Perspective.
51(16)
6. Analysis of Algorithms Framework. Classification of Algorithms. Computational Complexity. Average-Case Analysis. Approximate and Asymptotic Results. Basic Recurrences. Perspective.
67(14)
7. Implementation of Algorithms Selecting an Algorithm. Empirical Analysis. Program Optimization. Algorithms and Systems.
81(12)
Sorting Algorithms 93(100)
8. Elementary Sorting Methods Rules of the Game. Selection Sort. Insertion Sort. Digression: Bubble Sort. Performance Characteristics of Elementary Sorts. Sorting Files with Large Records. Shellsort. Distribution Counting.
93(22)
9. Quicksort The Basic Algorithm. Performance Characteristics of Quicksort. Removing Recursion. Small Subfiles. Median-of-Three Partitioning. Selection.
115(18)
10. Radix Sorting Bits. Radix Exchange Sort. Straight Radix Sort. Performance Characteristics of Radix Sorts. A Linear Sort.
133(12)
11. Priority Queues Elementary Implementations. Heap Data Structure. Algorithms on Heaps. Heapsort. Indirect Heaps. Advanced Implementations.
145(18)
12. Mergesort Merging. Mergesort. List Mergesort. Bottom-Up Mergesort. Performance Characteristics. Optimized Implementations. Recursion Revisited.
163(14)
13. External Sorting Sort-Merge. Balanced Multiway Merging. Replacement Selection. Practical Considerations. Polyphase Merging. An Easier Way.
177(16)
Searching Algorithms 193(84)
14. Elementary Searching Methods Sequential Searching. Binary Search. Binary Tree Search. Deletion. Indirect Binary Search Trees.
193(22)
15. Balanced Trees Top-Down 2-3-4 Trees. Red-Black Trees. Other Algorithms.
215(16)
16. Hashing Hash Functions. Separate Chaining. Linear Probing. Double Hashing. Perspective.
231(14)
17. Radix Searching Digital Search Trees. Radix Search Tries. Multiway Radix Searching. Patricia.
245(14)
18. External Searching Indexed Sequential Access. B-Trees. Extendible Hashing. Virtual Memory.
259(18)
String Processing 277(70)
19. String Searching A Short History. Brute-Force Algorithm. Knuth-Morris-Pratt Algorithm. Boyer-Moore Algorithm. Rabin-Karp Algorithm. Multiple Searches.
277(16)
20. Pattern Matching Describing Patterns. Pattern Matching Machines. Representing the Machine. Simulating the Machine.
293(12)
21. Parsing Context-Free Grammars. Top-Down Parsing. Bottom-Up Parsing. Compilers. Compiler-Compilers.
305(14)
22. File Compression Run-Length Encoding. Variable-Length Encoding. Building the Huffman Code. Implementation.
319(14)
23. Cryptology Rules of the Game. Simple Methods. Encryption/Decryption Machines. Public-Key Cryptosystems.
333(14)
Geometric Algorithms 347(68)
24. Elementary Geometric Methods Points, Lines, and Polygons. Line Segment Intersection. Simple Closed Path. Inclusion in a Polygon. Perspective.
347(12)
25. Finding the Convex Hull Rules of the Game. Package-Wrapping. The Graham Scan. Interior Elimination. Performance Issues.
359(14)
26. Range Searching Elementary Methods. Grid Method. Two-Dimensional Trees. Multidimensional Range Searching.
373(16)
27. Geometric Intersection Horizontal and Vertical Lines. Implementation. General Line Intersection.
389(12)
28. Closest-Point Problems Closest-Pair Problem. Voronoi Diagrams.
401(14)
Graph Algorithms 415(94)
29. Elementary Graph Algorithms Glossary. Representation. Depth-First Search. Nonrecursive Depth-First Search. Breadth-First Search. Mazes. Perspective.
415(22)
30. Connectivity Connected Components. Biconnectivity. Union-Find Algorithms.
437(14)
31. Weighted Graphs Minimum Spanning Tree. Priority-First Search. Kruskal's Method. Shortest Path. Minimum Spanning Tree and Shortest Paths in Dense Graphs. Geometric Problems.
451(20)
32. Directed Graphs Depth-First Search. Transitive Closure. All Shortest Paths. Topological Sorting. Strongly Connected Components.
471(14)
33. Network Flow The Network Flow Problem. Ford-Fulkerson Method. Network Searching.
485(10)
34. Matching Bipartite Graphs. Stable Marriage Problem. Advanced Algorithms.
495(14)
Mathematical Algorithms 509(60)
35. Random Numbers Applications. Linear Congruential Method. Additive Congruential Method. Testing Randomness. Implementation Notes.
509(12)
36. Arithmetic Polynomial Arithmetic. Polynomial Evaluation and Interpolation. Polynomial Multiplication. Arithmetic Operations with Large Integers. Matrix Arithmetic.
521(14)
37. Gaussian Elimination A Simple Example. Outline of the Method. Variations and Extensions.
535(10)
38. Curve Fitting Polynomial Interpolation. Spline Interpolation. Method of Least Squares.
545(10)
39. Integration Symbolic Integration. Simple Quadrature Methods. Compound Methods. Adaptive Quadrature.
555(14)
Advanced Topics 569(74)
40. Parallel Algorithms General Approaches. Perfect Shuffles. Systolic Arrays. Perspective.
569(14)
41. The Fast Fourier Transform Evaluate, Multiply, Interpolate. Complex Roots of Unity. Evaluation at the Roots of Unity. Interpolation at the Roots of Unity. Implementation.
583(12)
42. Dynamic Programming Knapsack Problem. Matrix Chain Product. Optimal Binary Search Trees. Time and Space Requirements.
595(12)
43. Linear Programming Linear Programs. Geometric Interpretation. The Simplex Method. Implementation.
607(14)
44. Exhaustive Search Exhaustive Search in Graphs. Backtracking. Digression: Permutation Generation. Approximation Algorithms.
621(12)
45. NP-Complete Problems Deterministic and Nondeterministic Polynomial-Time Algorithms. NP-Completeness. Cook's Theorem. Some NP-Complete Problems.
633(10)
Index 643

Excerpts

This book is intended to survey the most important computeralgorithms in use today and to teach fundamental techniques tothe growing number of people in need of knowing them. It can beused as a textbook for a second, third, or fourth course incomputer science, after students have acquired some programmingskills and familiarity with computer systems, but before theyhave taken specialized courses in advanced areas of computerscience or computer applications. Additionally, the book may be useful for self-study or as areference for those engaged in the development of computersystems or applications programs, since it contains a number ofimplementations of useful algorithms and detailed information ontheir performance characteristics. The broad perspective takenin the book makes it an appropriate introduction to the field. The algorithms are expressed in the C++ programming language(versions of the book in Pascal and C are also available). Nospecific knowledge about the language is assumed--the treatmenthere is self-contained (though fast-paced). Readers who havesome familiarity with C++ will find the language a useful vehiclefor learning a variety of methods of practical interest. Readerswho have some familiarity with basic algorithms will find thetreatment here a useful vehicle for learning a variety offeatures of the C++ language, while at the same time learningsome new algorithms. SCOPE The book contains forty-five chapters grouped into eight majorparts: fundamentals, sorting, searching, string processing,geometric algorithms, graph algorithms, mathematical algorithmsand advanced topics. A major goal in developing this book hasbeen to bring together the fundamental methods from these diverseareas, in order to provide access to the best methods known forsolving problems by computer. Some of the chapters giveintroductory treatments of advanced material. It is hoped thatthe descriptions here can give readers some understanding of thebasic properties of fundamental algorithms ranging from priorityqueues and hashing to simplex and the fast Fourier transform. One or two previous courses in computer science or equivalentprogramming experience are recommended for a reader to be able toappreciate the material in this book: one course in programmingin high-level languages such as C++, C or Pascal, and perhapsanother course which teaches fundamental concepts of programmingsystems. This book is thus intended for anyone conversant with amodern programming language and with the basic features of moderncomputer systems. References that might help fill in gaps inone''s background are suggested in the text. Most of the mathematical material supporting the analytic resultsis self-contained (or labeled as "beyond the scope" of thisbook), so little specific preparation in mathematics is requiredfor the bulk of the book, though a certain amount deal withalgorithms related to more advanced mathematical material--theseare intended to place the algorithms in context with othermethods throughout the book, not to teach the mathematicalmaterial. Thus the discussion of advanced mathematical conceptsis brief, general, and descriptive. USE IN THE CURRICULUM There is a great deal of flexibility in how the material here canbe taught. To a large extent, the individual chapters in thebook can be read independently of the others, though in somecases algorithms in one chapter make use of methods from aprevious chapter. The material can be adapted for use forvarious courses by selecting perhaps 25 or 30 of the 45 chapters,according to the taste of the instructor and the preparation ofthe students. The book begins with an introductory section on data structuresand the design and analysis of algorithms. This sets the tonefor the rest of the book and provides a framework within whichmore advanced algorithms are treated. Some readers may skip orskim this section; others may learn the basics there. An elementary course on "data structures and algorithms" mightomit some of the mathematical algorithms and some of the advancedtopics, then emphasize how various data structures are used inthe implementations. An intermediate course on "design andanalysis of algorithms" might omit some of the more practicallyoriented sections, then emphasize the identification and study ofthe ways in which algorithms achieve good asymptotic performance. A course on "software tools" might omit the mathematical andadvanced algorithmic material, then emphasize how to integratethe implementations given here into large programs or systems. Acourse on "algorithms" might take a survey approach and introduceconcepts from all these areas. Some instructors may wish to add supplementary material to thecourses described above to reflect their particular orientation. For "data structures and algorithms," more mathematical analysiscould be added; and for "software tools", software engineeringtechniques could be covered in more depth. In this book,attention is paid to all these areas, but the emphasis is on thealgorithms themselves. Earlier versions of this book have been used in recent years atscores of colleges and universities around the country as a textfor the second or third course in computer science and assupplemental reading for other courses. At Princeton, ourexperience has been that the breadth of coverage of material inthis book provides our majors with an introduction to computerscience that can be expanded upon in later courses on analysis ofalgorithms, systems programming and theoretical computer science,while at the same time providing all the students with a largeset of techniques that they can immediately put to good use. There are 450 exercises ten following each chapter, thatgenerally divide into one of two types. Most are intended totest students'' understanding of material in the next and askstudents to work through an example or apply concepts describedin the text. A few of them, however, involve implementing andputting together some of the algorithms, perhaps runningempirical studies to compare algorithms and to learn theirproperties. ALGORITHMS OF PRACTICAL USE The orientation of the book is toward algorithms likely to be ofpractical use. The emphasis is on teaching students the tools oftheir trade to the point that they can confidently implement, runand debug useful algorithms. Full implementations of the methodsdiscussed are included in the text, along with descriptions ofthe operations of these programs on a consistent set of examples. Indeed, as discussed in the epilog, hundreds of figures areincluded in the book that have been created by the algorithmsthemselves. Many algorithms are brought to light on an intuitivelevel through the visual dimension provided by these figures. Characteristics of the algorithms and situations in which theymight be useful are discussed in detail. Though not emphasized,connections to the analysis of algorithms and theoreticalcomputer science are not ignored. When appropriate, empiricaland analytic results are discussed to illustrate why certainalgorithms are preferred. When interesting, the relationship ofthe practical algorithms being discussed to purely theoreticalresults is described. Specific information performancecharacteristics of algorithms is encapsulated throughout in"properties," important facts about the algorithms that deservefurther study. Some algorithms are used in relatively small programs to solvespecific problems. Others play an integral part in relativelylarge systems. Many fundamental algorithms find application inboth domains. We indicate as appropriate how algorithms might bespecialized for use as problem-solving tools or generalized forintegration into much bigger programs. Such considerations areof particular interest for algorithms expressed in anobject-oriented language such as C+

An electronic version of this book is available through VitalSource.

This book is viewable on PC, Mac, iPhone, iPad, iPod Touch, and most smartphones.

By purchasing, you will be able to view this book online, as well as download it, for the chosen number of days.

Digital License

You are licensing a digital product for a set duration. Durations are set forth in the product description, with "Lifetime" typically meaning five (5) years of online access and permanent download to a supported device. All licenses are non-transferable.

More details can be found here.

A downloadable version of this book is available through the eCampus Reader or compatible Adobe readers.

Applications are available on iOS, Android, PC, Mac, and Windows Mobile platforms.

Please view the compatibility matrix prior to purchase.