Reddit reviews Data Structures and Algorithms

Ah, the age-old Drexel CS department dilemma...

tl;dr: Dr. Boady all the way if at all possible.

I've TA'd this course numerous times with numerous different instructors, including one term where I was assigned to both Dr. Nowak and Dr. Boady's sections of the course at the same time. It was kind of rough because whenever someone approached me to ask for help with the homework or go over a quiz or project, I'd have to remember to ask whether they had Boady or Nowak as the two versions of the course are very different while still ultimately covering the same material. I've also helped CS260 students in both Nowak's version and everyone else's version of the course in terms in which I was assigned to other courses, so I'm familiar with the course as taught by various instructors and the differences among them.

I sort of mentioned this last paragraph, but there are basically two versions of the course: the Dr. Nowak version and everyone else's version. The "everyone else" version has been very much influenced by Dr. Boady's changes over the past few years, so it's sort of become Dr. Boady's version moreso than everyone else's version.

I want to be clear here: Dr. Nowak is good. If you have to take it with him, it's fine, it's just less user-friendly than the alternative. The thing with Dr. Nowak though is that the's very much an old-school mathematician, maybe even more so than he is a computer scientist. That's not necessarily a bad thing; CS260 is basically a math course (not as much of a math course as CS270, however). People often forget that computer science is a mathematical discipline.

Dr. Nowak is also very set in his ways, perhaps to a fault. I think Dr. Boady may have finally found a suitable replacement for the Aho DS&A textbook (would you believe that some unscrupulous people use a PDF of this book they were able to easily find for free on the Internet rather than actually buying this??) via zybooks, so maybe every version of the course will use that from now on (and then again maybe all versions will still use Aho), but Aho is a pain in a number of ways. I get the sense Nowak is very attached to Aho as the standard textbook for the course.

Nowak's version will go through the text material in a different order than Boady, but his reason for doing so makes sense. While Boady goes through the chapters in their presented order, the first week or two of Nowak's version will cover chapters 1 & 9, skipping the 7 chapters in between (you'll circle back to them, though). This is because chapter 1 is "Design and Analysis of Algorithms" and chapter 9 is "Algorithm Analysis Techniques," so the two chapters are closely related. However, the material in chapter 9 is a bit more complicated and challenging than what you'll find in the first few chapters, which is why the Boady version covers it later in the course.

Really, the two chapters should probably be merged, but like I said: Aho is kind of a pain sometimes.

Boady's version will have more of a programming focus than Nowak's course while Nowak will require more theoretical assignments (stuff like formal proofs, or finding closed form expressions of summations, etc.). Boady's will still have theory questions and Nowak's will still have programming assignments, but the emphasis on each is different.

I vastly prefer the Boady version of the course. This is due to a number of reasons that I'll get into, but in the interest of full disclosure, one of the biggest factors is that Dr. Boady and I work very well together and I feel like we're on the same wavelength a lot of the time. He and I go way back, and one might even say that we "roll mad deep" (no one has ever said this but please feel free to start).

Dr. Boady is also incredibly good at teaching. Like, in addition to his computer science research, he's spent time actively keeping up with the research on education. One thing I find he does the best is that his labs and assignments (I don't think there are "labs" for 260 but it's been awhile) have the questions presented in a very deliberate manner such that they build off each other as you go; if you follow the order of the problems/questions as assigned, they start easy and get incrementally more complicated based on the previous question (or questions) until you reach an item that would have seemed extremely difficult if you looked at it first, but you are well-equipped to understand and solve based on the questions/problems you've already handled.

In my experience, people find that Dr. Boady is much more approachable and easy to converse with compared to Dr. Nowak (or most people, really). Dr. Nowak is a nice person and all, but I've had a few kind of funny awkward interactions with him stemming from simple misunderstandings, but nothing that made me feel like he was trying to insult me or scare me away or whatever.

Finally, one of the most important things is that Dr. Boady is much, much closer to being in your position as a student. I don't know if this is common knowledge or anything, but he did his undergrad degree at Drexel, immediately entered the graduate program here, and started working as teaching faculty as soon as he finished his PhD. He's literally taken this very course, and he took it recently enough that he remembers what it was like to be on the other side of things. A problem that I often find with older professors in general is that they're too far removed from the time when they didn't know any of the material that they're now teaching and that they may have struggled to learn it themselves and what ultimately helped them understand. When I started here, Dr. Boady was just a grad student named Mark; he understands where most of his students are at because he was in the same position relatively recently.

Anyway, I'll wrap up: he's passionate about the material and passionate about teaching and he's always actively looking for ways to refine the way he teaches his courses each term.

...but Dr. Nowak has some cool idiosyncrasies. Like, he pronounces "algorithms" as "algoritmas" and refers to the elements of a proof as "ingredients," so if you take it with Boady, you'll miss out on that ¯\_(ツ)_/¯

Hope that helps.

EDIT: I counted the chapters incorrectly which is not great in a post giving advice on computer science or math courses.

Code Complete: http://www.cc2e.com/Default.aspx
Data Stuctures and Algorithms: http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237

>I didn't really get that much coding experience in actually implementing my own versions of the data structures that were covered.

Nothing's stopping you, don't need a book to do that. If you learned the theory and are familiar with the ADTs it should be a piece of cake. I actually think it's better for classes to stay abstract and teach more theory - too many students get caught up in languages, but these concepts are higher level than that.

This one is solid but if you are looking for something to walk you through implementing them then you should just use online resources. This site has implementations and should cover everything you need and more (plus it's free)

Awesome list, thanks for sharing. This so very useful to me as I'm currently in an apprenticeship to become a software developer and am working through this textbook Data Structures and Algorithms and could use all the other helpful links I can get!

> I am pretty realistic

>I would like to become a computer programmer overnight.

L OMG L

That said, read something like this http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237 . The language you choose is nearly irrelevant vs the concepts you'll need to apply.

Data Structures and Algorithms. Aho, Ullman & Hopcroft

Relax. There are plenty of good books, but most of them will actually be your course literature in university. You do not gain anything substantial by trying to go through that now. Instead make sure that CS is the right field for you at all. Figure out what studying CS is all about, realize that it will not be like taking programming classes for 4 years. Instead, like I said, work on basic programming skills. Lots of students go into CS without being able to program, and you'll have a much easier time if you have familiarity with practical concepts by then.

If you really want some classic books, though:

• Aho, Ullman & Hopcroft have the classical book on algorithms.
  
  
• The Dragon Book on compilers. You'll probably use this in a compiler course. Warning: don't try this now. It's a complicated book and requires being comfortable with some other theory.
  
  
• Russell and Norvig have the book on AI. Definitely difficult in places, this is perhaps my favourite CS book. You can take a look at it to learn what studying AI is like, but keep in mind that a full-semester course at university will only cover part of the book. According to the book itself, covering it in its entirely is expected to take two full semesters.
  
  
• The Dinosaur book is the typical text for an OS course. Note that in terms of a CS course, operating systems doesn't so much mean studying the difference between Linux and Windows, but rather learning about process scheduling, virtual memory, deadlocks and that sort of thing.

Awesome exactly what I was looking for. I did order 3 books on Amazon yesterday.

Data Structures and Algorithms
http://www.amazon.com/gp/product/0201000237/ref=oh_details_o00_s01_i00

C# In Depth
http://www.amazon.com/gp/product/1935182471/ref=oh_details_o00_s00_i01

C# In a Nutshell
http://www.amazon.com/gp/product/0596800959/ref=oh_details_o00_s00_i00

I did a little research and those came up as great books. I did get them used though, totaling 60 dollars free shipping with prime. Any good recommendations for a design patterns book?

most recommended book in my courses is "Modern Operating Systems" or "Computer Networks" from Andrew Tannenbaum or http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237

Data Structures and Algorithms is what I used in my class... not so easy to read but a ton of sample code that is easy to understand. I would recommend checking it out at a library before buying it, though... my class was fairly 50/50 on who liked it and who didn't.

> Data Structures and Algorithms

http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237

Is this the book you're referring to?

I've been focusing on C# for the past year when I can. Currently "developing" an archiving tool for certain files that I am hoping to use as a resume piece. Trying to show off things like MVVM, IoC/DP, async/await, cloud storage integration and the new .net stuff. Metro style UI, maybe.

I know that C++ is in demand, but I thought I'd have an easier time starting with C#, which I also see a lot of firms looking for. Based on the networking I've done, C#, Javascript, or C++ would all have been good places to start. I just want to get my foot in the door somewhere. Getting past the resume glance inspection is my biggest hurdle.

If you don't have time/want to get results quickly then you could look into using Navmeshes. Otherwise you need to get your hands dirty with some algorithms.


Most people use A*, DBF, or Dijkstra. There are tons of easy to find resources on them.
A good book that has a few chapters dedicated to graph traversal is Data Structures and Algorithms




Sidenote, how are you using raycasting with the zombies? If you simply want them to not run into shit and don't really care about how smart they are, a simple solution would be to get the radius of the collider around the zombies, check if another collider has collided with it, if it has then make the zombie rotate x degrees and begin moving again. OnCollisionEnter should be sufficient enough. Just make sure the prefab zombie has a collider on it and each wall has a collider.

Princeton's class on Algorithms and Data Structures

JavaWorld's Data Structures and Algorithms in Java tutorial

And my old standby: Aho, Hopcroft, and Ullman's Data Structures and Algorithms

I suggest you read some books that focus more on the general topic, IMO they provide more information and are more understandable.

Back when I was in university the first book about A/DS I read was "Algorithms and Data Structures" by Niklaus Wirth. I've looked it up now and it's freely distributed by the author in PDF format. http://people.inf.ethz.ch/wirth/

Then I read "Data Structures and Algorithms"
by Aho, Ullman and Hopcroft https://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237

and "Introduction to Algorithms" by Cormen, Leiserson, Rivest and Stein https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

Those books overlap in many parts, but it never hurts to re-read about a subject to better understand and memorize it. The first book is smaller in volume as compared to the other two, so it might be a good start, but judge for yourself - look at the tables of contents and compare what you find more appealing.

This book is excellent. Yes, the code samples are in ancient languages, but the explanations are clear and you're learning it from masters of the craft who know it thoroughly and explain it thoroughly.

Another book to add to the list:
Data Structures and Algorithms (Aho, Hopcroft, Ullman)

It's very easy to follow, the examples are in pascal.
If you have the CLRS book, with that you are ok. This is much shorter.