The authors provide an clear and concise set of criterion for the use of algorithms in general, and then go about developing the basic set to use in daily development of your own. I got this book as a reference to assist newcomers and interns in their progress, but find myself referring to its contents frequently to remind myself of some foundational elements that have floated merrily away over the years.

I would heartily recommend this book to everyone. For the student to learn the basic set of algorithms, for the entry and mid level software engineers (or programmers) to inspire new ideas from a solid foundation, and for us veterans as a reminder to a solid way for development of our own algorithms.

It is well written, and easy to understand (even for the interns I've had read through it). The examples are developed around Java, and so the book starts with a section on Java and basic programming techniques. It contains a large set of the basic algorithms that are frequently necessary on a day to day basis, but also shows HOW and WHY they were developed. It also provides a section on several advanced topics, again with an eye to the HOWs and WHYs. All along the way, there are references to "Good" development foundations, and reminders the development philosophies.

Short and simple this book WALKS you through what data structures are, their purpose and use. It teaches you not only the concepts but provides complete code examples. What I particularly liked is how the book teaches you to systematically test and measure the performance of the data structures and points out why it performs as measured using both mathematical theory as well as data driven analysis. The content of the book is presented in an order which allows you to learn gradually and use what was learned in earlier chapters to develop more complex ideas in later chapters. This book can be read by absolute beginners, meaning you don't need a prior exposure to data structures to grasp the content as it progresses from simple to advanced. Another great point is this book goes out of its way to give real world applications and uses of the data structures and their associated algorithms; giving the reader a real grasp on the usefulness of the content, making it real, not just an academic pursuit. There is no shortage of material, a very good balance of breath and depth.

For the experienced programmer or novice this a book you will appreciate and be glad you purchased.

If genius is like it is said, the ability to make a complex subject simple to understand then Robert Sedgewick is truly a genius.

Sedgewick explores some of the top algorithms in use today and focuses on their application, and implementation. Each algorithim, it's application, and performance is also summarized for quick reference.

Sedgewick steps through the algorithm with dynamic visual depictions of the data structures involved.

I can't say enough good things this book. This book assists the developer or programmer to effectively learn and use algorithms, and get on with life. It's rare to see a book this well written for the purpose of learning as well as reference. Especially on a subject as involved as algorithms.

In conjunction with the book, I would recommend using the online MOOC courses, Algorithms Part I, and Algorithms Part II, available at Princeton University. Here, Sedgewick, has developed some enjoyable and instructional video lectures and presentations of the book.

I would also like to thank Robert Sedgewick for this brilliant piece of work, and Princeton University for bringing it online.

The author has talent of simplifying complex concepts as nobody else does. That's for sure. I would even go as far as calling him Feynman of Computer Science.

His treatment of 2-3 trees, Red-Black Trees is outstanding. In the first time in my life I understood the Regular Expressions. Not on a level of "what's it about", but on a level of "when I need to use them, I will no problem, I'll even implement all algorithms I need no problem with all the books closed".

That creates even a dissonance a little bit. Or a lot. As some topics in his exposition sound very boring, banal. It reads like he is stating obvious facts for no apparent reason as to fill the space and just "to cover" the topic for some formal reasons.

CONS:

- Most of the chapters are not self-sufficient. Instead of conceptually pointing out what steps are required, the author send you to a specific, very specialized piece of code 5 chapters back or 3 chapters forward. Code is in Java. It's painful to read. Not because it's in Java, but because it's _implementation_ of a concept. Java is bad, too verbose, too specialized, etc.

- The programming language used in the book is Java. Java is a language for people who have no idea of what they are doing and have no business of writing algorithms. I believe any person who will write any algorithm will use C. Why Java then? Why not Logo? (Logo is a language where a turtle moves across the screen and kids give it some commands like "go forward 10 squares, turn 90")

Besides these cons, the author is definitely genius. 2-3 trees chapter and the Regular Expressions chapter are worth the price of the whole book. In gold.

This book is a very clearly written, and cogent treatment of basic algorithms. It's contents are presented within the construct of the Java language, and for a reader already conversant in an imperative Algol based language (such as C, C++, or JavaScript), enough of the relevant features of Java are covered in the text to allow for complete understanding of the material presented.

I've read several books on algorithms of varying complexity, and this is hands down the best beginning level book I've ever read. If you've tried reading other algorithm books, and either found the presentation too dry, too technical (symbolic, mathematical, pseudo code), this is the book you want. It not only describes the algorithms in a very clear, very understandable way; it also presents them in context and with code in a subset of Java (that it also very clearly explains). I started with it reading the Kindle sample, and liked it so much, I purchased the hard bound physical version. 'Nuff said!

I got this book just before Thanksgiving break. I had the plan to finish as much as possible during the Thanksgiving break.

I had earlier read Sedgewick's Algorithms book (C++ version).

So comparing to that, this Java version is similarly organized.

The basics are touched comprehensively in this book as well: heaps, priority queues, sorting - quick sort, merge sort, stacks, queues, binary trees, tries and so on.

I liked the fact that since this was a Java version, authors kept in mind to discuss details of the object organization as well. So things like how much memory a string object occupies was good to learn from this book.

This book touches in detail algorithms like Substring search (Boyer moore, Rabin Karpe) and has a whole chapter devoted to strings.

So datastructures like tries are covered as well in good details.

Also I liked the fact that authors made it a point to refer to the current real world applications whenever possible - for example application of dictionary lookup in Page rank algorithm was another good learning.

There are some sections extra in this book campared to the C++ version.

Overall a satisfactory book, a must-have for software engineers.

Fantastic book. Well-crafted. My need is to understand the algorithms that are already out there and most importantly, to understand the applications where they might apply so that I may apply existing algorithms (or modifications) to my applications. This book delivers 100% on that. The runtime traces have phenomenal visuals. The algorithms that you are trying to learn are detailed near the visuals in Java code. Apparently, there is conflict in academia whether actual code should be used to demonstrate algorithimic ideas. For me, it is an advantage to see actual code instead of "pseudo-code". Java is not in my pipeline, but C++ and Python is. But it still helps to see actual implementations, even if it is in Java. This book is nicely paired with the author's Coursera classes. The Coursera courses are like drinking for a firehose, but introduce you to the material in a timely manner. After that, reading the book is like having a peaceful picnic by a babbling stream, peaceful and quiet. Reading the book is particularly effective after attempting the Coursera course for the first time. After reading the book, go back to the course and get it all done.

The book is about algorithms and data structures in Java, and not about learning to program. My review will contrast this book with Sedgewick's 25+year old "Algorithms in C++" in my shelf. The new algorithms book is such a vast improvement over the old C++ book that I hardly recognize it any more. The new Algorithms has two authors. The authors are using a sub-set of the Java OO features (unlike the C++ version, which used none). While I may not agree in detail with some choices, I can understand, because they explained their coding standards well, and why they limit features. The algorithms are updated to the basic algorithms a student these days needs to have heard of, which includes new material like tries. I was fascinated to see a regular expression evaluation automaton in code, with explanations. Some more esoteric material from the C++ book (for instance, Voronoi diagrams) is left for specialized books. At a few places in the book, the impact of algorithms and data structures is illustrated giving real-world examples. And I have yet to read chapter 6.

But what really impressed me was the code. This book shows the fundamental data structures and algorithms in just a few lines of beautiful and well-thought code. Sure, any nit-picker may find quibbles, but most choices are understandable from a didactic and printing perspective. This code is so much better than any in the old C++ book. The authors preferred clarity, yet the code is still concise. The authors are clear about feature creep, and limit their code to what is needed and no more, though some extensions are part of the exercises. I am reminded of the Einstein paraphrase "As simple as possible, but no simpler".

More complex data structures and algorithms need multiple code boxes, which are all explained in detail, with the box appearing close to the explanation. Some readers may take issue with the density of information in examples, but I find it advantageous to have all information close-by rather than spread out. I prefer to pore over their dense examples than having to flip pages.

If you want to digest different algorithms used in practice, then Sir Robert Sedgewick will help you out through this book. This book is a "must" if you are willing to learn and master over algorithms (focuses on Java implementations). I had referred this book when I was in college and was very much impressed by the way in which Sir Sedgewick explains. Paperback copy of this book is slightly expensive and moreover if you own a kindle, why go for a paperback edition?? Hence went ahead and purchased this kindle edition.

Spiega in modo unico davvero, ne ho letti diversi di testi di algoritmi, penso che questo sia il migliore in assoluto!

The book teaches algorithms with a scientific approach and there is no magic everything is proved. The code is simple and elegant. The author has also online course explaining the book content.

There is also community driven GitHub repo containing answers to all book’s exercises.

The only thing that I didn’t like is the absence of unit tests.

Es un libro muy cuidado con un gran cantidad de ejercicios y sus soluciones. Todo informático debería conocer. La web es extraordinaria. Lo recomiendo encarecidamente, vale la pena.

I have quite a few algorithms books. This certainly is one of my favourites. The current edition starts out with a gentle introduction to motivation and basics, but soon ramps up to be a solid algorithms book. I recommend this as a first-read before moving on to the book by Cormen (which is much more theoretical and heavy going at first).