Introduction to Algorithms

With sample problems and mathematical proofs demonstrating the correctness of each algorithm, this book is ideal as a textbook for classroom study, but its reach doesn't end there. The authors do a fine job of explaining each algorithm. (Reference sections on basic mathematical notation will help readers bridge the gap, but it will help to have some math background to appreciate the full achievement of this handsome hardcover volume.) Every algorithm is presented in pseudo-code, which can be implemented in any computer language, including C/C++ and Java. This ecumenical approach is one of the book's strengths. When it comes to sorting and common data structures, from basic linked lists to trees (including binary trees, red-black, and B-trees), this title really shines, with clear diagrams that show algorithms in operation. Even if you just glance over the mathematical notation here, you can definitely benefit from this text in other ways.

The book moves forward with more advanced algorithms that implement strategies for solving more complicated problems (including dynamic programming techniques, greedy algorithms, and amortized analysis). Algorithms for graphing problems (used in such real-world business problems as optimizing flight schedules or flow through pipelines) come next. In each case, the authors provide the best from current research in each topic, along with sample solutions.

This text closes with a grab bag of useful algorithms including matrix operations and linear programming, evaluating polynomials, and the well-known Fast Fourier Transformation (FFT) (useful in signal processing and engineering). Final sections on "NP-complete" problems, like the well-known traveling salesman problem, show off that while not all problems have a demonstrably final and best answer, algorithms that generate acceptable approximate solutions can still be used to generate useful, real-world answers.

Throughout this text, the authors anchor their discussion of algorithms with current examples drawn from molecular biology (like the Human Genome Project), business, and engineering. Each section ends with short discussions of related historical material, often discussing original research in each area of algorithms. On the whole, they argue successfully that algorithms are a "technology" just like hardware and software that can be used to write better software that does more, with better performance. Along with classic books on algorithms (like Donald Knuth's three-volume set, The Art of Computer Programming), this title sets a new standard for compiling the best research in algorithms. For any experienced developer, regardless of their chosen language, this text deserves a close look for extending the range and performance of real-world software. --Richard Dragan

Topics covered: Overview of algorithms (including algorithms as a technology); designing and analyzing algorithms; asymptotic notation; recurrences and recursion; probabilistic analysis and randomized algorithms; heapsort algorithms; priority queues; quicksort algorithms; linear time sorting (including radix and bucket sort); medians and order statistics (including minimum and maximum); introduction to data structures (stacks, queues, linked lists, and rooted trees); hash tables (including hash functions); binary search trees; red-black trees; augmenting data structures for custom applications; dynamic programming explained (including assembly-line scheduling, matrix-chain multiplication, and optimal binary search trees); greedy algorithms (including Huffman codes and task-scheduling problems); amortized analysis (the accounting and potential methods); advanced data structures (including B-trees, binomial and Fibonacci heaps, representing disjoint sets in data structures); graph algorithms (representing graphs, minimum spanning trees, single-source shortest paths, all-pairs shortest paths, and maximum flow algorithms); sorting networks; matrix operations; linear programming (standard and slack forms); polynomials and the Fast Fourier Transformation (FFT); number theoretic algorithms (including greatest common divisor, modular arithmetic, the Chinese remainder theorem, RSA public-key encryption, primality testing, integer factorization); string matching; computational geometry (including finding the convex hull); NP-completeness (including sample real-world NP-complete problems and their insolvability); approximation algorithms for NP-complete problems (including the traveling salesman problem); reference sections for summations and other mathematical notation, sets, relations, functions, graphs and trees, as well as counting and probability backgrounder (plus geometric and binomial distributions).

Product Description
The first edition won the award for Best 1990 Professional and Scholarly Book in Computer Science and Data Processing by the Association of American Publishers.

There are books on algorithms that are rigorous but incomplete and others that cover masses of material but lack rigor. Introduction to Algorithms combines rigor and comprehensiveness.

The book covers a broad range of algorithms in depth, yet makes their design and analysis accessible to all levels of readers. Each chapter is relatively self-contained and can be used as a unit of study. The algorithms are described in English and in a pseudocode designed to be readable by anyone who has done a little programming. The explanations have been kept elementary without sacrificing depth of coverage or mathematical rigor.

The first edition became the standard reference for professionals and a widely used text in universities worldwide. The second edition features new chapters on the role of algorithms, probabilistic analysis and randomized algorithms, and linear programming, as well as extensive revisions to virtually every section of the book. In a subtle but important change, loop invariants are introduced early and used throughout the text to prove algorithm correctness. Without changing the mathematical and analytic focus, the authors have moved much of the mathematical foundations material from Part I to an appendix and have included additional motivational material at the beginning.

I haven't seen a better textbook ! Here are some reasons:

1. The discrete mathematics foundations are present in the first few chapters of this book and so, you can quickly brush up on any discrete math background that you may require while using this book.

2. The style of writing is very light and at the same time, rigorous - almost as if you are in the middle of a lecture while reading the book.

3. The material is comprehensive and serves as an excellent reference for other courses and in your future career.

4. The exercises and problems provide a very good learning experience.

5. It's a good-looking book !


A Very Solid Introduction to Algorithms   December 8, 2000
Donovan Rebbechi (Jersey City, NJ United States)
57 out of 63 found this review helpful

It's a good thing that this book has a hard cover (make sure you get the hard cover edition, huh?), because otherwise mine would be in pieces. This book is my favourite book on algorithms. All the others seem somewhat unsatisfactory to me -- they are tied to particular programming languages, they are paperback, and they are for the most part less comprehensive than this book. (except Knuth, which is somewhat more advanced). See the summary of the TOC below for an outline of what the book covers. I guess Sedgewicks new title has been getting better reviews, but it's still not hard cover (-;

This covers a lot of topics, and covers them in some level of mathematical rigor. For example, all assertions about algorithm efficiency are backed up with *proofs*, and key concepts like asymptotics, and big-O notation are covered. To those who think proofs are not essential -- as a mathematician, I'd counter that proofs are absolutely necessary, because you don't know something until you've proven it -- it's easy to make wrong "guesses", or even wrong hand-waving arguments. The examples are all in pseudo-code. Personally, I liked this as it makes implementing the data structures an interesting exercise that forces the reader to think.

The subject matter covered is quite broad, see below. There are some interesting topics that don't get covered (eg AVL trees), but this book does a good job at laying down the foundation.

Some might be intimidated by the theoretical approach, but I for one like it. It's written for computer scientists (or "software engineers"), not get-rich-quick wannabees. This book will force you to think, and if you don't like that, well you can (and should) buy "learn algorithms in 21 seconds" from SAMS or something.

You'll need some background to digest this material. Someone with a year of programming and some discreet math should be ready for it. Note that you won't learn any programming *language* from this book (unless you count pseudo-coed), so you'd better know some before starting !

Summary: PartI: Intro, Growth of functions,Summations, Recurrences, Sets, Counting and Probability

Part II: Heapsort,Quicksort, Sorting in linear time, Medians/order statistics

Part III: Stacks/Queues/Linked lists, Hash tables, Binary search trees, Red-Black trees, Augmented data structures

Part IV: Dynamic programming,Greedy algorithms, Amortized analysis

Part V: B-trees, Binomial heaps, fibonacci heaps, data structures for disjoint sets

Part VI: Elementary graph algorithms, Minimal spanning trees, single-source shortes paths, all pairs shortest paths, maximum flow

Part VII: sorting networks, arithmatic circuits, algorithms for parallel computers, matrix operations, polynomials and fft, number theoretic algorithms, string matching, computational geometry, NP-completeness, Approximation algorithms.


Complete, thorough...   August 3, 1999
64 out of 73 found this review helpful

Quote from a previous review:

Instead of touching on new technologies, such as AI, graphics, or anything else remotely relevant to today's demands on programmers and designers, this book, faithful to its MIT roots, gives a pompous, eggheaded distortion to the field of computers as a whole. Its focus is mainly on such trivialities as algorithm analysis, offering about 10 pages of proofs for each simple assertion. The points that the authors hope to make have no relevance whatsoever in a world in which processor power, not meticulous code optimization, reigns.

----------

I've had Cormen (one of the authors) as a professor in class, and my algorithms class uses this book, so admittedly my view might be a bit biased. But if you read the above (quoted) review, you might have gotten the wrong impression about this book. Cormen et. al. *intentionally* left "AI and graphics" algorithms to other authors; this isn't the place to cover those topics enough to do them justice. And as someone who has actually read the book, each proof is *not* 10 pages long. The examples are usually quite good, and concisely (if thoroughly explained). Finally, prof. Cormen always explains to his intro CS students why the study of algorithms is important, even as computers get faster and faster: some problems, poorly implemented, just *will not* run as well on a machine of today compared to a much older machine running a better algorithm. There will *always* be a justified place for the study and analysis of algorithms. Had the previous reviewer actually had met Prof. Cormen, he wouldn't be able to write the book off with the title of "pompous" or "eggheaded" either...


The definitive reference for data structures and algorithms   February 2, 2003
Todd Ebert (Long Beach California)
28 out of 30 found this review helpful

While working as a software engineer, my supervisor, who also wrote programs for a living, had a book on his shelf, "Data Structures and Algorithms", written by Horowitz and Sahni. It was one of the most tattered-looking hardback books I had ever seen! (a true indicator of the worth of a book). Moreover, I view the Cormer, Leiserson, Rivest book as an updated version of this book, in that it has the same core content of data structures and algorithms, and presents the algorithms in psuedocode instead of a GPL like C++. I find this book, however, not only better written than its predecessor, but also containing a number of advanced chapters (e.g. computational geometry and parallel computation) that reflects the explosion of the study of algorithms over the past 20 years. If I had to choose one book on data structures and algorithms to have on my shelf it would be this one, as no other modern text compares with it in terms of its breadth and depth of the subject material. However, for those students or practitioners who prefer to learn about data structures and algorithms within the context of a progromming language, I recommend Mark Weiss's book on data structures and algorithms, both in Java and in C++. His book seems less developed and rigorous, but he gives good examples, explanations, and more practical insights.


Rigorous coverage of the most widely used algorithms   December 5, 1999
Steven Nicolaou (Boston, MA)
37 out of 41 found this review helpful

I personally bought this book in preparation for the International Olympiad in Informatics (IOI), and it helped me immensely in getting off the ground with the algorithms I had to learn, especially the chapter on Dynamic Programming. Since then, however it has remained a priceless companion during my studies and at home.

This is the definitive reference for algorithms with a firm theoretical and mathematical foundation. Algorithms are treated with a thorough theoretical introduction often with a complete mathematical walkthrough, a clearly thought out solution, a discussion of its pros and cons, lots of clear and consisive diagrams, a pseudocode implementation, and a good deal of serious optimisation discussion. It's written in an accessible manner, starting with the elementary issues, progressing to the advanced and complex thinking needed to conquer them, so you'll find you have to give it your full concentration.

This book will not disappoint. Its explanations are rigorous and its coverage spans all the general purpose algorithms with little focus on their applications but rather on the algorithms themselves. The book covers such major areas as sorting, data structures, advanced design and analysis techniques, graphs, each about a hundred pages on average, and a selection of specialised algorithms such as parallel programming, string matching and computational geometry. Because these algorithms are used everywhere, from games, graphics and simulations to electrical engineering it will have a broad audience and will find a home almost anywhere there is serious programming involved. Each chapter is a unit in itself which means you don't need to read it cover to cover, since they all start off smoothly and handhold you through. Clearly written by professionals, this is the book I know contains the information that I can't find elsewhere.