To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzes reviews to verify trustworthiness.
After seeing all the positive reviews, I had high hopes for this book but didn't enjoy reading it at all. The chapters are dull and dry. Lots of paragraphs that are hard to read and make sense of. Few pictures and even those black and white pictures don't have numbers; so, sometimes it is hard to know which picture the author is talking about. The code examples are not great either. The indexes of arrays start at 1 to make it easier to understand for non-programmers but makes it harder for programmers, and yet it is highly mathematical and abstract even for me as a programmer. I find it hard to believe a non-programmer can read this book and make sense of most of it.
I am reading lot of algorithms books lately due to rekindled interest (the last time I am this motivated is during my high school days!) and the common advice is to read CLRS (C for Cormen) but the book is a 500 pound gorilla and it is neck deep in detailed Math. Imagine my delight when I stumbled on "Algorithms Unlocked" by Cormen - I call this book Baby Cormen. My background is in software engineering and I am paying my dues for 10+ years. I like math but am not in touch with it for many years; though I am currently taking steps to remedy it. So that’s the context. Here goes my review:
1. It has a section on "Algorithms on Strings". Out of many books that I perused (Algorithms in a nutshell, Skiena, Eva Tardos etc.), this book, CLRS, Algorithms by Sedgwick has a section on Strings. There are dedicated books on String algorithms but "string problems" appear practically in almost every software engineer's career that I think any general algorithms book should cover a basic portion of it. This one does.
2. Chatty but neither boring nor tedious. It uses enough words to convey the concept efficiently.
3. It contains math for sections on complexity but algorithm concepts are supported with pictures, sample algorithm runs. One just needs to follow logical arguments as it is explained.
4. All the chapters except last few pages in chapter 9, 10 are gems.
5. The length of the book is ~222. This cannot be overstated. The faster u reach towards the end of the book the better you will feel about yourself and the more you will like to finish it.
6. Pretty good paper quality and print. Love this about MIT press.
7. Price is cheap.
8. No exercises. Yes this is a good thing actually. It would have affected the flow of the book. If you need exercises then go to Big Cormen (CLRS).
1. Typos/Errors. 14 when I counted. I actually thought it cannot have any because some reviewer here said it was copyedited by someone who is a stickler for perfection so I didn't bother to check the errata page (my bad but only 14 errata’s is still impressive) until I stumbled on a possible typo (it turns out it is not) and tried to contact the author by going to the book's website. One should make sure to correct it in the book before reading.
2. Chapter 9 - section on LZW compression/decompression could have been little clearer. Chapter 10 - section on Hamiltonian cycle to Hamiltonian path reduction, subset sum reduction could have been little clearer because the explanation had more gaps in logic than usual. The author did say in the preface that he couldn't control getting into more details near the very end of the book but I felt the explanation was unclear because it is rushed than more technical details are employed.
All in all this is a solid book that treats you as an intelligent human being than a space alien or a brick.
Admittedly, I'm not finished with it yet & may revise this review later on... So far I've read up through the Sorting chapters.
As stated in other reviews & in the book's intro, the author assumes no prior programming knowledge. It's confusing to consider Arrays as starting a 1 & having to add/subtract everywhere, but ok I can deal with it...
What wasn't clear at purchase time was the assumption of familiarity with math at let's say "Algebra II" or pre-calc levels. If you don't understand or remember how to deal with factorials, polynomials, exponents & logarithms, you'll need to look those up.
These are not particularly difficult or high-level, but my last prolonged exposure to these concepts was more than a decade ago. I do appreciate the need to keep the concepts abstract enough to apply across various applications, but it would be nice to see some concrete implementation. I'd have a much easier time following code examples in a language/syntax I've seen more recently. I'm considering the "Algorithms 4th Ed" book by Sedgewick & Wayne for that reason: practical application w/examples in Java.
Modern programming best practices described in books like "The Pragmatic Programmer" or "Code Complete" also clearly emphasize the need to use unique/meaningful names for variables and functions so that people can easily follow your work. It also helps YOU to follow your own work. This book instead takes you back to math class where everything is a meaningless jumble of alphabet soup - "x,y,z,q,p,r,a" - and you have to constantly bounce back & forth (sometimes over several pages) to keep track of what's what.
Which example gives you a better idea what's going on?:
sortedBooksArray = unsortedBooksArray[x]
... OR ...
A[q-1] = R[p]
Yes, algorithms should be abstract, but if the goal is to explain them clearly they need to first be presented in a concrete way. This is why so many people hate & don't understand math - those who love & understand it fail to describe the practical uses for it in understandable terms. The notation & abstraction work against the stated goal of making algorithms more accessible.
Perhaps that's by design, because I'm going to wind up re-writing the psuedocode with my own examples to gain a better understanding. This weekend I will have stacks of books strewn about the living room while I attempt to implement QuickSort for real, and will thereafter come up with some scenarios where I can implement it in code myself. But in that case, I probably could've gotten the same effect from an online tutorial...
So far, it's not a bad book - I just haven't really learned anything practical, or that I didn't already know from other online sources that present the topic in a more understandable manner.
Upon un-boxing, I looked at the back cover photo and thought, "uh-oh, another Ivy League professor who thinks everything is intuitively obvious, and disrespects you if it's not." One of the reasons more Americans don't go into computer science IMHO is that the basics are NOT intuitive, and turning your class into a boot camp - with programming assignments made purposely too time consuming - does nothing but hinder....oh, wait, this is a book review, I digress.
Anyways, this book is NOT that, it's a good book. For example, chapter 2 goes from assuming no knowledge of computer programming to asymptotic notation, and it's actually understandable! I've taken an algorithms class, and although able to muddle through it, I only understood about 1/4 the theoretical part. This book helps fill that void and I have renewed confidence that I will be able to understand the more theoretical aspect to algorithms the next time I encounter them (I'm back in school studying CS at night). I've read this book once, from cover to cover - retaining about 1/2 of it. Now it's a second time with highlighter and notes so that I can retain the book in its entirety.
It's not really a book for the "we're all going to be cyborgs, algorithms rule the world" pop-computing crowd, and I suspect it would take a gifted reader to understand this book if he or she truly had no clue about programming. A computer program algorithm is a different way of looking at the world than most folks are used to. But in the first chapter - presumably the one somebody would thumb through at the book store - the author actually points the reader to a less technical book if this one seems too technical.
This book would be an awesome supplemental text for a class involving logic, critical thinking, scientific thinking, mathematical thinking, or an undergraduate computer science course on algorithms.
The only thing I thought missing were some exercises so I could test that I truly mastered the chapter. Would be cool if there was a website related to the book that had worked out examples to replicate the text so I'd have to actively duplicate what the book explains.
This is an interesting book. It's halfway between the typical science-book-for-non-scientists and a textbook. Unlike most science books for non-scientists, the author doesn't dumb down the material for the reader; he assumes you're intelligent and are willing to work a bit to understand what he says (including following mathematical arguments with actual equations). In fact, I only bought the book because the author was Cormen; I was familiar with his algorithms textbook (Introduction to Algorithms, better known as CLRS after the initials of the authors), which is absolutely authoritative, so I knew the material would be correct. (Having Julie Sussman, P.P.A., as the proofreader was also a big plus.) Unlike CLRS, this is not a textbook, but rather kind of a "pre-textbook". Its purpose is to whet your appetite, to teach you enough about the material so that you can decide if you want to study it more formally or not. If so, you can go straight to CLRS. If not, at least you'll have learned something. The people who will get the most out of this book are self-taught programmers who have never taken a course in algorithms but who nevertheless need to know this material. (And believe me, if you're a programmer, you _do_ need to know this material, whether you realize it or not.) Non-programmers may find that the book is too technical (especially the last few chapters, which get fairly heavily into topics like number theory and reductions of NP-complete problems). Despite this, I can think of no other book that provides such a clear introduction to the field of algorithms with so few prerequisites. Cormen's explanations are lucid and interesting throughout, and the topics are motivated by real-world applications which often don't find their way into textbook descriptions. Algorithms are described using a kind of pseudocode which is similar to that found in CLRS, but with a lot more written exposition. Overall, this is a great book if you're interested in the topic, or think you might be. Personally, I greatly prefer this kind of "pre-textbook" approach to the usual popular science book approach, and I hope that the example this book sets encourages more textbook writers to write such books.
I bought this on the recommendation of a friend - I have the very famous 'intro to algorithms' book but haven't had time to dig in since it's a massive tome and wanted something more concise. This however might be a little too far in the opposite direction: I would have preferred to see things in code or pseudocode. The examples also start loops at 1, which for me is just an annoyance since I know better, but I imagine this may cause issues for the novice java/c/c++ programmer who misses the caveat in the early chapters. Perhaps it is my fault for not previewing the book before purchasing
I studied from the excellent textbook "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest in Professor Hubscher's COMP-0527 Advanced Design and Analysis of Algorithms three hour course in the Fall Quarter of 1999 at Auburn University. I made my first B in my computer science graduate school career in the course. I was also taking Professor Carlisle's COMP-0520 Theory of Formal Languages I course in which I made an A and either Professor Lim's or Baskiyar's COMP-0600 Advanced Systems Programming which also garnered me an A. My cumulative GPA dropped from 4.0 out of 4.0 to 3.91 that quarter. I ended my Master of Software Engineering career at Auburn on August 14, 2000 with a 3.880 GPA and my Computer Science Doctor of Philosophy at Auburn on December 16, 2005 with a 3.871 GPA.
Now back to Cormen's "Algorithms Unlocked". For someone who is sometimes theoretically challenged in computer science like me, the level of mathematical sophistication or unsophistication depending on your computer science theoretical background of the little book makes it an excellent introduction to algorithms covered in more depth in the large and somewhat more intellectually formidable algorithms textbook. The book is not exactly a watered down version of the original textbook and offers some new insights not afforded in the more massive tome. Overall I would recommend both the little and big algorithms books to all serious students or practitioners of computer science and software engineering. Also, somewhat mathematically sophisticated scientists in other fields could benefit from reading "Algorithms Unlocked".
To be fair I'm only about half way through this title as of now, but I'm impressed. Why you may ask? As the author mentions quite often, he is one of the authors of An Introduction to Algorithms (CLRS), which is the de facto standard in university level algorithm courses. It's also one of the longest, driest, most boring texts I've ever had the displeasure of being assigned to read. It's very thorough and filled with proofs and other gory details of algorithm analysis. Not that I don't appreciate its depth, but it's tough to keep up with at times (especially for students balancing three other courses and a job). But reading this title, I'm pleased with the light hearted tone and the almost humorous use of real work examples that strong algorithms can solve like cooking kungpo chicken in the shortest possible time and putting all hockey goalie equipment on the correct order without having to remove any pieces. The funny thing is that many of these algorithms are the classics that CLRS teaches as well, just trimmed of all the snobby proofs and focused on getting the actual message across. Proofs are important as well as understanding fundamentals of how algorithms perform. But I feel that CLRS is a bit to lo cluttered with these and it tends to skew the educational potential of the content. In fact, given the authors tone, I would almost think he agrees with me.
When I took the grad level Analysis of Algorithms course at the University of Florida, I did not have a background in computer science. I had an undergraduate degree in electronics and my graduate level course work was split between hardware and software. I approached the subject with apprehension (and some awe). The book I used for the class was the other book by Cormen and his friends, fondly called the CLRS. Most of the time the mathematics in the book was too much for me; I had to spend many a sleepless night to figure stuff out. But I still loved the book. Now that I am mid-way through Algorithms Unlocked, I wish I could have bought this book back then (sadly, it came out only this year, i.e. 2013). The algorithms are explained in English, not just mathematics or pseudo-code, and I found all the chapters to be perfect for a beginner. If you are someone who is interested in algorithms and has at least some background in mathematics, this is the book for you. Even if you do not have the requisite background in maths, you can use the internet to learn the basics of what is required. Dr. Cormen has done an outstanding job here, having written the perfect introductory book which can then lead to his other classic, the CLRS book.
This is a clear, plain English explanation of algorithms, loop invariants, and how to describe time complexity. It starts with very introductory, basic material (linear search, binary search, selection sort...) but it makes easy-to-understand, unambiguous points and walks you through how the proof of correctness and complexity determinations work. I have previously taken a course on data structures and algorithms, and I will be taking a course on algorithm design soon. I am considering also getting Cormen's larger textbook, regardless of whatever text my university chooses. It seems to me that a programmer needs to be absolutely crystal clear in his understanding of data structures and algorithms or he won't be able to do quality work. This book is very much an introductory text, but its clarity and approachability is invaluable toward ensuring that I am not misunderstanding anything in the subject area. I wish this author had written my discrete math text!