The Algorithm Design Manual by Steven S. Skiena

The Algorithm Design Manual Reviews

• 
  Christian Brumm

  In comparison to "Introduction to Algorithms" (the other algorithm book I had significant exposure to) this one is faster to read, easier to digest and more tailored towards applications.
  
  I found the "Hitchhiker's Guide to Algorithms" in the back to be extremely useful if you really find yourself tackling an algorithmic problem in practice.
  
  The main part (maybe skipping/skimming down a few chapters) is a very good preparation for algorithm-heavy job interviews (e.g. Google, Facebook etc ...).
  
  Very much recommended.
• 
  محمد

  This is not an introductory book. You should have some previous knowledge of algorithms to enjoy it. The book builds a way of thinking towards solving algorithms problems, instead of just stating the algorithms and data structures in a mechanical way, but in many parts it is not very clear and you have to read a passage multiple times to understand what the author meant.
  
  The book can be used as a reference that you can use to understand a specific topic.
• 
  Josh Davis

  I can't think of an occasion when I'd recommend this over Intro to Algorithms (CLRS). It does a fraction of what CLRS does and worse in most cases. And in the rest of the cases, it does them exactly the same. There were some instances (graph algorithms) where the code in Skiena was taken straight out of CLRS. Not only did CLRS explain the algorithm better but it had the proofs to back it up.
  
  Speaking of proofs, this is what I hated about Skiena. It has barely any proofs in comparison to CLRS. A lot of people might enjoy this, but I feel that having the mathematical understanding of algorithms and the proofs to back it up will greatly increase your understanding of the material. A short proof instead of a little hand waving goes a long way.
  
  Basically, get CLRS and don't look back.
• 
  Nick Black

  great practical guide, lots of fun to read on the subway. probably a better book to carry around in one's professional life than CLR, though it lacks some of the theoretical intensity of the Big White Book. i'm interviewing with Google and Amazon this week and picked it up to refresh myself on graph algorithms and strategies for NP-complete problems, and it delivered, with perhaps greater effect (and certainly less time) than rereading
  Algorithmic Graph Theory and
  The Theory of NP Completeness.
• 
  Joe

  The rare computer programming book that I finished start-to-finish.
  
  The first half of the book tells you why some things take longer to compute than other things. This helps data scientists / statisticians / analysts who work with large amounts of data.
  
  In the first half, the math and the computer code can get pretty heavy. But I found the text around it was written so you could skim the hard stuff, get the idea, and keep going.
  
  The second half of the book is a reference. As Hadley Wickham said in
  his review on Fivebooks, this is helpful for Googling things. I've found that a lot of computer programming is easy if you just know the name of thing you need to Google. This gets you there.
• 
  Nick Greenquist

  Long and difficult book to get through. I did most of the problems but started skipping many towards the final chapters (8 and 9). I also skipped all the problems in chapter 10, which dealt with NP hard problems and approximate algos and more proofy ones about reducing problems down to satisfiability. This was mostly because I already knew going in that I wasnt interested in those sections (did them and school and realized that they're not that useful unless you go into research or academia).
  
  But regardless, the reason for the 3 stars is that this book tries to straddle the middle of being a practical interview prep book and being a proof heavy, theoretical Algo book.
  
  If I were to go back in time, I'd probably pick either a 100% practical Algo book or something like CLRS for very rigorous understanding.
• 
  Matt McCormick

  A very thorough book but I found that the explanations for most algorithms could have been better. I found it to be more of a reference book for looking up how to write an algorithm if you need one rather than learning well about a variety of algorithms.
• 
  Badarudheen Kunnathodi

  Highly recommended for anyone interested in practical algorithm implementation.
• 
  Valia

  A rare book on algorithms that is actually fun to read :)
• 
  Alexander Osmanov

  Very good examples and explanations of algorithms that are commonly asked in interviews.
• 
  Sophie

  Though this is a 1998 edition, it explains essential algorithms concisely.
  
  Notes
  
  pp. 28-32
  Fundamental Data Types
  1. Containers:
  • Fundamental Operations:
  Put(C,x): Insert a new data item x into the container C.
  Get(C): Retrieve the next item from the container C. Different types of containers support different retrieval orders, based on insertion order or position.
  • Popular Types of Containers:
  (1) Stacks - Last in, first out (LIFO). The put and get operations for stacks are usually called push and pop.
  (2) Queues - First in, first out (FIFO). The put and get operations for stacks are usually called enqueue and dequeue.
  (3) Tables: Supports retrieval by position, so that put and get each accept an index as an argument. Tables are naturally implemented using arrays.
  2. Dictionaries:
  • Primary Operations:
  Search(D, k): Given a search key k, return a pointer to the element in dictionary D whose key value is k, if one exists.
  Insert(D, x): Given a data item x, add it to the set of items in the dictionary D.
  Delete(D, x): Given a pointer to a given data item x in the dictionary D, remove it from D.
  • Certain dictionary data structures support the following operations:
  Max(D) or Min(D)
  Predecessor(D, k) or Successor(D, k)
  3. Binary Search Trees
  4. Priority Queues
  
  pp. 36-38
  
  Approaches to Sorting
  1. Data Structures: Repeatedly extracts the smallest remaining element from the unsorted part of the set but will take a total of O(n^2)time aka heapsort.
  

  
  SelectionSort(A)
  For i = 1 to n do
  Sort[i] = Find-Minimum from A
  Delete-Minimum from A
  Return(Sort)
  

  
  2. Incremental Insertion: Select an arbitrary element from the unsorted set, and put it in the proper position in the sorted set. Though it takes O(n^2) in the worst scenario, it will perform much better if the data is sorted.
  

  
  InsertionSort(A)
  A[0] = -∞
  for i = 1 to n - 1 do
  j = i
  while (A[j] > A[j-1]) do swap(A[j], A[j-1])
  

  
  3. Divide and Conquer: Suppose we take n elements to sort and split them into piles S and T, each with half the elements. After sorting both piles, it is easy to combine the two sorted piles and takes O(n log n) in the worst scenario.
  

  
  MergeSort(A[1, n])
  Merge( MergeSort(A[1, [n/2]]), MergeSort(A[[n/2] + 1, n]))
  

  
  4. Randomization
  5. Bucketing Techniques
  
  
  
• 
  Vibhor Rawal

  When I picked it up, I instantly became a fan of Skiena. Some of the writings span beyond algorithm design and it was a delight reading those. Especially the war stories helped as a reader to get a clearer picture of an algorist's job. Though in my opinion the book deteriorates in writing quality (not knowledge imparted per chapter), it still is a good design manual, don't get me wrong the worst pages of this book felt superior to some other books out their.
  
  ===========================================
  Here are some of the wordings that were a sugar candy to read-
  
  Proofs are useful only when they are honest.
  
  Pseudocode is perhaps the most mysterious of the bunch, but it is best defined as a programming language that never complains about syntax errors.
  
  recursion is mathematical induction.
  
  a computer scientist is a mathematician who only knows how to prove things by induction.
  
  algorist as “one skillful in reckonings or figuring.”
  
  The moral of logarithmic growth is clear: “If you are gonna do the crime, make it worth the time!”
  
  An Ω(n log n) lower bound can be shown by observing that any sorting algorithm must behave differently during execution on each of the distinct n! permutations of n keys. The outcome of each pairwise comparison governs the run-time behavior of any comparison-based sorting algorithm. We can think of the set of all possible executions of such an algorithm as a tree with n! leaves. The minimum height tree corresponds to the fastest possible algorithm, and it happens that lg(n!) = Θ(n log n).
  
  Strategy represents the quest for the big picture—the framework around which we construct our path to the goal. Tactics are used to win the minor battles we must fight along the way. In problem-solving, it is important to check repeatedly whether you are thinking on the right level. If you do not have a global strategy of how you are going to attack your problem, it is pointless to worry about the tactics.
  
  ===========================================
  
  This book definitely helps solidify some ideas, but the second half didn't sell for me (where it's all here's some algos, these are the places you will find them, ask these questions to yourself for finding how and if to use these) . It did not feel thorough in the sense that most of the algos given are briefly discussed and their implementation is out of the bounds of the book, maybe it suffices it's purpose and for some it will be a blessing to find the references material and latch onto it for more information. But for me it distinguished this book from a 5 star to a 4.
• 
  Michael Burnam-Fink

  Skiena is incredible!
  
  I'll be upfront that I'm a pragmatist as a programmer. I some actual training in data science and machine learning, which is arcane enough on it's own, and a few years experience to call myself Good With Pandas, but the thing about being an autodidact solving a limited set of business problems in Python is that you miss the big picture. In a mature ecosystem like Python, a lot of the time the right answer is just "pip install magiclib. from magiclib import incantation. bar = incantation(foo)" Except sometimes magiclib doesn't exist yet. At the end of the day, computers are all Turing machines, they all solve the same sets of problems, but some approaches are algorithmically tractable, and some will leave you lost in the Swamp of Sadness.
  
  
  Artax has been asked to solve a large NP complete problem
  
  For someone who's never taken CS101, this book an eye-opener into the hows and whys of basic data structures like linked lists, trees, hash tables, and arrays, as well as sorting techniques and more advanced practices like dynamic programming. Clear explainers are interspersed with practical war stories, where Skiena explains how he applied the technique just discussed to solve a previously intractable problem.
  
  Cracking the Coding interview is a series of dog tricks. The Algorithm Design Manual is actual knowledge. It's been a great guide to actually thinking like a professional, even if most of the day job is data plumbing.
• 
  Ivan Koma

  (FR) Я бы мог начать выпендриваться и восторгаться книгой, но для людей с моим интеллектом могут возникнуть проблемы... Я вообще не понял вторую главу дальше начала
  Мне всегда казалось что если ты пишешь книгу, ты должен написать ее на таком языке, чтобы даже самый тупой человек (я) мог немного понять её, тут же у меня было ощущение, что кто-то решил поиграться "нейронными мускулами", это конечно не претензия, просто когда я читал становилось скучно, и это при том что я люблю формулы и прочее, но примеры просто что-то, чем ты не проникаешься, а порой и вообще не понимаешь что это за ерунда (ясновиденью привет)
  Сразу говорю что читал в русском переводе, может быть это сказалось, но иногда хочется что-то читнуть на своем языке, возможно это не лучшая идея, распространять такую хотелку на технические книги
  И еще в книге 60% упражнений, решил ли кто-нибудь их все, останется загадкой навсегда...
• 
  Danial Kalbasi

  A useful read for anyone who likes to have a deeper understanding of algorithm design. The book covers many aspects such as time/space complexity, NP-completeness, and many other concepts. The part that I personally really appreciate was the first few chapters about how to set our mindset to design an algorithm.
  
  This book, like most academic books, is hard to read and comprehend and needs the reader to do more research about the subjects. I wish people who write these books, they come out of their academic cave. It doesn't need to use complex writing structures or tough vocabularies to explain a simple idea.
  
  This book, of course, is not something you read from A to Z. It's probably good as a reference.
• 
  Kirill

  Most of the books in this category provide a rigorous catalog of different algorithmic problems and their solutions, and this one is not an exception. At least its second part. What makes this books stand out is its first half. There, author provides a practical view on solving algorithmic problems, providing intuitive explanations of the major problems in each category. Each of the first 10 chapters also contain war stories, where the algorithms are brought to real practical applications based on the author’s experience.
  And if you’ll need a more complete reference, the second part of the book contains a more traditional collection of various algorithms with topics ranging from sorting to black box optimization.
• 
  Tech Nossomy

  Comprehensive albeit verbose book on algorithms for computational problems. Target audience primarily undergraduate computer scientists, but will be helpful to more seasoned software developers and scientists as well. Written in the first person. Applicability in a wide range of industry sectors is well argued. Bibliography spans 40+ pages, giving ample opportunity for further research.
  
  Second edition still contains a typo here and there (eg page 43: S(n) =≥ (n/2) × (n/2)) and verbosity could have been replaced with more rigorous treatment of algorithm runtime analysis, although author discounts for this editorial choice on page 57.
• 
  Scott Holstad

  A pretty good resource and one of the better books on the subject, in my opinion. However, many describe it as "introductory" algorithms, and I'm not sure I totally agree. Unless you already posses a solid foundation in related areas, a newbie will often find it hard to walk into this and immediately understand it. And maybe some will say that would be unrealistic, and I would be one of those. However, I actually have heard and seen others say exactly that, and again, I don't agree. Nonetheless, a pretty good book and solid resource. Recommended.
• 
  Philippe Fanaro

  A work of art and mastery of many fields. Decades and decades of research in addition to the much more valuable big picture of their integration. This is *the* book to bridge the gap between theory and practice.
  
  I don't know if this book could be read with someone with zero knowledge of the topics involved. I am a graduate student of electrical engineering who knew a reasonable lot before trying this book out and, still, couldn't read more than 40-60 pages a day (I separated 2 weeks off for this book).
• 
  Bookich Store

  The ebook
  The Algorithm Design Manual (Texts in Computer Science) covers all the basic algorithms that any and every programmer and data scientist is expected to know.
  
  for anybody with a CS degree, this is just a review. –– but I like only having to look in a single book for all the basic algorithms.
  
  Buy the ebook now:
  
  
  The Algorithm Design Manual (Texts in Computer Science) 3rd ed. 2020 Edition
• 
  Harry Harman

  Indispensable reading for any computer scientist.
  
  An algorithm is a procedure that takes any of the possible input instances and transforms it to the desired output.
  
  In industrial settings, any program that seems to give good enough answers without slowing the application down is often acceptable, regardless of whether a better algorithm exists. The issue of finding the best possible answer or achieving maximum efficiency usually arises in industry only after serious performance or legal troubles
• 
  Mi Lia

  One can never say that he's done reading this book. As it's one of the books that you return all the time to. Very practical as a handbook as half of it is like a dictionary of algorithms and the problem each one of them solves. The author gives lots of code samples in-text in C. Very well written, humorous, and practical. If you need a first book for your Algorithms and Data Structures class, start with this one. Then go to the bible (CLRS). Great job prof. Skiena.
• 
  Priyanka Shah

  Amazing and informative book for anyone interested in knowing how algorithms shape the world we live and power almost all the electronic machines we interact with on day to day basis. Most importantly gives you a zoom out version to analyze and breakdown big problems into small informative chunks which can then be processed to get a value.