Much of the industry uses algorithm and data structure problems as a way of assessing "smartness" in interviews -- the idea is that even though it's often not needed for the job, giving people the challenge of learning that area at the intersection of computer science and software engineering correlates with how strong a contributor they'll be. I.e. if you don't know it but can pick up an area like that, that's a good signal. So a course like this (doing all the homework exercises) would definitely help with interviewing and getting jobs that people are competing for, if that is something that interests you.

The actual content in this data structures course obviously will mostly not appear in any interview, but the homework exercises will make you stronger in a way that is definitely desirable for interviews. And of course, interviews aside, it will all be interesting for anyone that has an intellectual interest in software engineering.

I guess it depends on what you do and your goals. It might be not necessary to do average developers job (and full disclosure, it wasn't necessary 10 years ago as well). But understanding fundamentals gives you insights to be better prepared to choose right 'interface' when you need to. Also you can see it as a way to stretch your 'programmer muscles'.

After going through lecture topics list, I think most of those you actually need to know as a working programmer. Not because they are prerequisites, but because after couple of years in the field, you will have to touch most of those topics anyway.

A CS degree is meant to teach computer science, not just programming. Algorithms and data structures are the most fundamental concepts in computer science.

A working programmer probably needs to have the general rudiments of algorithmic analysis to write good code--to understand why a O(1) algorithm is usually better than an O(N) algorithm, to understand what makes an algorithm O(1) or O(N), and to understand the basic properties of the canned library functions they use.

The basic list and map datatypes (array list, linked list, balanced search tree, hashtable) are good ways to get through these concepts, although hashtables and balanced search trees are in the oh-god-don't-ever-try-to-implement-these-yourself category. Graphs are also a pretty versatile data structure that has wide use, it certainly doesn't hurt to learn about all the algorithms already solved for graphs and how they might be adapted to your use cases. Tries, compression, and disjoint sets are I think a little too niche (although I do end up using disjoint sets a fair amount).

I would say yes.

The students are learning about lists, sets, and maps. These are so common that misusing this stuff can lead to big consequences during engineering design.

the difference is using tools vs building your own tools when you need to. the idea of these algorithms is not to memorize them but to understand how they are build and what goals they are trying to accomplish. understanding of the basic building blocks allows approaching and solving problems in a different light.