Excellent course material, including the programing assignments.

I wish there were additional programming assignments spanning more topics from the course (shorter ones in addition to those in this course).

best algorithm course I've ever seen!

非常好，清晰明了。

Still waiting for Kevin Wayne to appear... In all seriousness, the course was incredibly tough for me (someone who is not a compsci major) but was also very rewarding. It took me 6 weeks to complete and probably around 10 hours per problem set. Kdtrees was the most interesting pset and collinear points the least (wording was slightly confusing for me).

I would like to provide the following advice for those who are struggling but really wish to complete it.

1. Go through the lectures and try to implement the data structures yourself (unless he says it's not necessary e.g. llrb tree) e.g. in week 1, I made my own QuickFind and QuickUnion class. It doesn't have to be perfect but it helps to grapple with the idea.

2. Always look at the FAQ and command line input/output example. Coupled with reading the specification clearly should clear up 90% of the issues in what you are required to implement (unless it's the collinear points pset). If still confused, reading the discussions may be helpful.

3. Try to do the psets when your brain is working at its best. Writing something half baked late in the night will probably lead you to take longer than if you hadn't written anything at all.

4. Lastly, have patience. The fact that you're struggling so much means that you have the most to gain from solving the psets. Focus on the learning gains you will get rather than the difficulty you're having right now and you'll see it's all worth it in the end.

Thank you very much for making this high quality resource publicly available at no cost.

The content was easy to understand. However, the professor is not as enthusiastic as I expected him to be, and the programming assignments are focused more on applying an already implemented data structure to a problem rather than writing algorithms from scratch.

Literally one of the best courses (not just in algorithms) I have ever done in my whole life, and I have done a ton of courses. And Professor Robert Sedgewick is my new all-time favourite professor right now. The pros: 1. Tough concepts are explained in a beautiful way for everyone to understand. 2. Especially loved the clarity in terms of the professor's explanation. 3. Normally, courses on algorithms don't focus on coding implementations. But this course is different. It gives a detailed coding implementation (in Java) for every algorithm/data structure we learn. This gives an insight into how industry strength code is designed. 4. For a person who has perfectionism like me, I worry a lot about the structure and outline of the topics and the courses. This course perfectly makes me happy in this regard. 5. Every single thing the professor talks about has some meaning and importance to it. Zero fluff. 6. We can see the passion in the professor's eyes as he explains every concept. The cons: 1. None that I can think of. Bottomline: This course is a MUST-DO for every person who is aspiring to become a software developer. This course bettered my understanding of algorithms and data structures. It also made me a better programmer for sure.

Lectures are pretty good and material is fairly well explained. Be warned that significant knowledge of Java is expected and it isn't taught here.

Topics are interesting, explanation is boring

I spent hours trying to setup my Intellji environment. No help on the web whatsoever. Course material seemed great, but the instructions for the programming were non-existent.

The instructor has a very bad speech problem I guess. Before every word, he speaks 'uh', 'ah' 'uhh'.

Very irritating.

Too much detailed first assignment containing open-ended irrelevant tasks. Got bored.

No certificate issues after lot of hardwork

The course is just awesome. The course is taught by an expert in the field, and that fact reflects in the content of the course. The assignments are well designed and very involving, which helps the learner think deep, come out with a solution, improve the solution as much as possible after autograder evaluation, which is really good. That way, the learner consolidates the concept which he/she learned in the video lectures.

Also I see there are many people complaining about enforcement of the Java as the programming language for assignment submission. In my opinion, that is not a probelm at all, if you are strong in some other language, say C++, it is very easy to adapt and in the process you end up learning, not just Data Structures and Algorithms, also a new language, Java, which is a very widely used language. People should see it as a boon, since it gives double returns for your efforts. I feel very bad, because it is only because of the enforcement of Java, some people gave bad rating for the course.

WINNERS TRAIN, LOSERS COMPLAIN

Personally, I think that the assignments in this course (not in the Algs textbook) did negligible improvement in solving problem. On the other hand, writing assignments feels like doing a Java project on your own. This feels not bad since it's not easy for programming noob like me to explore and participate in projects on GitHub owing to lack of confidence : (. BTW the autograder is so awesome that it even examines your Java code style! This is pretty good for students who had learned C/C++ before to form a better code style in Java. For the videos, it's pretty good for novice (I've been confusing for a long time to find a good way to start and learn Data Structure). However, in other words, the CS knowledge taught in this course is far beyond needed. It's still necessary to drill yourself on other sites like LeetCode, and learn the relevant mathematical algorithm analysis (maybe by reading Introduction To Algorithm).

Still, I will definitely proceed with the Part 2! Genuinely appreciated, Mr. Sedgewick!

All is great except that there are too many "um"s in lecture videos. But that's totally tolerable considering Professor's age.

Anyway, I've learned a lot from this course, especially those fabulous PROGRAMMING ASSIGNMENTS!

Good curriculum, but poor presentation.

These are the building blocks for physics engines and data structures, and most people won't have to implement this directly, but it's helpful to understand applications and limitations. Nearly all coding interviews will ask about these concepts as well, so this material has lots of value in finding a job. The explanations are detailed, and the visualizations for the various data-types are fairly good.

That said, there is room for improvement. After the first couple of assignments, I switched to auditing this course, because of all the issues.

- The content was not migrated very well, resulting in many/most exercises having disclaimers that they haven't been migrated yet, and others having links to resources that will need a few extra step to work. I think the materials might just be out of sync with the assignment descriptions, but they certainly didn't go smoothly for me.

- Practice problems have hints, but no answers. It's useful to think through, but you either know the answer, or you don't. You're probably better off just working through problems on codeforces.

- Long lecture format was from a traditional classroom. This works alright, but feels a bit bloated in comparison to other Coursera courses I've taken. The checkpoints are trivial, and added after production, so they didn't add much either.

A very well made and informational course. However, it is quite difficult, specifically the projects. Even as a CS undergraduate, this really was not easy at all. This certainly also requires a lot more time dedicated to it than suggested.

Help is way too cryptic to be actually helpful.

Too much time to setup and no explanation on how to use the algorithms in Java. It just tells you to import the package. The discussions do not help much either. I'm a CS student at a state school and found this way too confusing. The only value in this course appears to be the videos but definitely NOT the exercises. It may suit other learning styles but not mine.

É ruim pq o curso é em ingles, e pelo menos a legenda deveria ser em português, e até a legenda ta em inglês também, pra quem está iniciando e não tem nenhum conhecimento em inglês é péssimo.

Endless technical issues with Java class paths and config etc, and sparse, unclear assignment specifications makes this course a inefficient use of time.

crap outdated installation wasted a shit load of my time do the berkley course instead way more accessible

didn't get certificate

One of the best courses I did. I am guilty of not finishing many courses on coursera, but this one kept me hooked and motivated enough to keep coming back at regular intervals and actually finish. The actual learning from the course is more than just algorithms as we get detailed feedback on style and even some design aspects of the code we submit. The only downside of such depth assessment review system is that we are forced to use Java for the solutions, sometimes which can have its own learning curve, and hard to get 100% score because of some nitpicks which are not worth spending time to fix for a course assignment (they would be for actual production code though). Also, the specs provided are sometimes missing requirements which we only find out by submitting once and reading the assessment with failed tests.

One thing that I think should be improved is the hint system for quizzes. After we submit, in most cases the hints are not enough to understand how to solve the problem. So it leaves you less fulfilled than ideal, knowing there is unsolved problem out there and no real help.

Overall, totally recommended.

I have taken several online courses, mostly on Coursera, which I've enjoyed and learned a great deal from. However, I would have to say that this is the best online course I've taken so far. The subject matter revolves around some of the most fundamental algorithms for computer science and emphasizes the importance of data representation. The choice of Java as a programming language for this course helps emphasize the distinction between data structures and abstract data types. The lectures relate the material to concrete and interesting real-world applications but also occasionally mention related open problems in computer science. The instructor is very clear in his explanations, which often make use of excellent and helpful visualizations. Lastly, the assignments are challenging but rewarding and the feedback provided by the automated grader, which accounts not only for correctness of the submitted APIs and their implementations, but also for coding style, timing, and memory use, is an invaluable learning tool.