Author: Robert Sedgewick| Kevin Wayne. Scheduling: Theory, Algorithms, and Systems, 4th Edition. Data Structures and Algorithms in Java, 4th Edition.
This fourth edition of Robert Sedgewick and Kevin Wayne's Algorithms is the leading textbook on algorithms today and is widely used in colleges and universities worldwide. This book surveys the most important computer algorithms currently in use and provides a full treatment of data structures and algorithms for sorting, searching, graph processing, and string processing - including fifty algorithms every programmer should know. In this edition, new Java implementations are written in an accessible modular programming style, where all of the code is exposed to the reader and ready to use. The algorithms in this book represent a body of knowledge developed over the last 50 years that has become indispensable, not just for professional programmers and computer science students but for any student with interests in science, mathematics, and engineering, not to mention students who use computation in the liberal arts.
The companion web site, algs4.cs.princeton.edu contains An online synopsis Full Java implementations Test data Exercises and answers Dynamic visualizations Lecture slides Programming assignments with checklists Links to related material The MOOC related to this book is accessible via the 'Online Course' link at algs4.cs.princeton.edu. The course offers more than 100 video lecture segments that are integrated with the text, extensive online assessments, and the large-scale discussion forums that have proven so valuable.
Offered each fall and spring, this course regularly attracts tens of thousands of registrants. Robert Sedgewick and Kevin Wayne are developing a modern approach to disseminating knowledge that fully embraces technology, enabling people all around the world to discover new ways of learning and teaching. By integrating their textbook, online content, and MOOC, all at the state of the art, they have built a unique resource that greatly expands the breadth and depth of the educational experience. I read this textbook while taking Sedgewick's online Algorithms class on coursera.com.
It covers the fundamental algorithms in searching, sorting, graphs, and string processing. There's a consistent focus on application examples, which really helps provide useful context. I found the explanations very clear and easy to follow. A strength of the book is that all algorithms are given in real working Java code, and great care has been given to making the code concise and readable. This can also be seen as a weakness, as large portions of the book are devoted to introducing a basic Java programming model, and to discussing specific Java implementation details. As someone who writes code for a living, I really appreciated this aspect of the presentation, but I could understand if someone else found it distracting.
Overall, this is an excellent work for learning the fundamental algorithms of computer science from a very practical and applications oriented perspective. Highly recommended. This is far more approachable than CLRS, yet more thorough than Skiena's The Algorithm Design Manual.
It doesn't cover as much ground - certainly not when compared to CLRS. For instance, there is no mention of dynamic programming and no general discussion of greedy algorithms. But what it does discuss is thoughtfully presented in a meaningful sequence so this can, and should, be read cover to cover. It seems like the product of someone who has considered the material deeply from several angles over many years. I knew most of the material already, but this book gave me several fresh perspectives and unexpected new insights. The source code is Java, which I much prefer to the pseudo code in CLRS or the C in Skiena's book. However, the first 200 pages or so are a rather dry introduction to Java which doesn't really belong in an algorithms book and which most people can skip.
The Java in the book is very simple and it's not unreasonable to expect everyone to know that much Java already. Oddly, the authors avoid using big-O notation, often discussing constant factors that don't seem like they could be particularly relevant compared to how CPU memory cache behaviour (data locality) would affect efficient implementations of different algorithms, particularly as the code is in Java. Though the graph section mentions the Ford-Fulkerson Max-Flow algorithm, it doesn't mention the all-pairs shortest paths algorithms such as Floyd-Warshall, usually dealt with first - maybe because it belongs in a discussion of dynamic programing. It does have some excellent explanations of the Knuth-Morris-Pratt, Boyer-Moore and Rabin-Karp algorithms for substring search, explaining them in terms of deterministic finite state automata. That leads to a really good section on implementing regular expression searches with non-deterministic finite state automata. These really expanding my mind. First of all, the book has excellent and free site with exercises, presentations, and examples at which is great!
Then, there are 2 courses by prof. Sedgewick at Coursera, which is great also. There are lots of diagrams, and algorithm traces, and also lots of useful exercises to do by yourself.
Well, and what I don't like is that there are passages that go like 'this should be obvious from.' And you're like 'What? Why this is obvious, it is not obvious for me at all!!!' But I think every book on algorithm has such passages. Other than that I like this text very much.
There are also minor drawbacks like, for instance, Java code doesn't always follow Java code style conventions, and maybe some other issues but they are not very important for me. Of course, reading the book, and not doing any exercises is not very helpful but overall I got myself acquainted with lots of very elegant and beautiful ideas in the field of computer science and that was amazing. And by the way, Kindle version has some errors and typos in it. Overall it's good, and it has nice code images that fit into one screen, but sometimes it's hard to identify errors, that's all.