Join Simon Allardice for an in-depth discussion in this video What you should know, part of Foundations of Programming: Data Structures.
This is a course for programmers. It's not about the visual presentation of data, it's about the inner workings of data inside a computer program. And what the nature of this course means, we won't focus on specific syntax for just one language. I will be discussing data types, variables, program flow, memory. I need concepts like iteration and recursion. So what I expect from you is general programming skill. You've been programming anything from a few months to several years, but you're comfortable developing in a general purpose programming language. You're good with the jargon and concepts of software development, including object orientation, and you're not baffled if you see a different language from your personal favorite.
Now, if you've watched any of my other Foundations of Programming courses beyond the first fundamentals course, you'll have a good idea what to expect here. I'll often use pseudo-code or simplified examples from common languages. I'm going to avoid using a lot of examples with pointers because we shouldn't need them to understand these concepts. And I want you to find this useful whether you're building Java desktop applications, C# class libraries, Objective-C mobile apps, Python web applications, or anything else that might arise in the future. And that's the right attitude.
It's not about any particular language right now. What we're doing right now is building deep, valuable skills of a professional software developer. Sidebar, I'd like to speak for a moment to those of you who are primarily self taught. First, congratulations for being here and watching this. Seriously. I've been programming professionally for over 30 years and I've taught for over ten to people with and without computer science backgrounds. Among many of the best programmers I've ever worked with are primarily self taught. If I was to pick one area that was neglected in self-taught programmers, it's this one.
Data structures are often their biggest blind spot. Why? Well, usually because it's never been urgent. They've managed okay without diving any deeper into this. You can still write a lot of code if all you know how to do is use a raise. Let's face it. When we have a programming problem, it is often more tempting to just dive into the algorithm. How do we solve this? What are the steps that we need to do? And kind of shrug off the underlying data structure we're using to solve it. But I don't ever want to do another code review where I ask someone, hey, why didn't you use a hash table over here, and all I get is a blank look and a shrug and a, well, I didn't think it made much of a difference.
Well it does, and when someone could vastly improve the performance of their code by picking an alternative data structure and they don't know that, that's a problem. And if you ever go in for an interview with a company like Google, or Microsoft, or Apple, or Facebook, or anyone doing software engineering at that level, they will expect you to know this stuff. So, welcome and let's get into this. We're going to begin this course by getting perfectly clear about what this term, data structures, actually covers.
Starting with simple ways of grouping data like arrays and structs, together you'll explore gradually more complex data structures, like dictionaries, sets, hash tables, queues and stacks, links and linked lists, and trees and graphs. Simon keeps the lessons grounded in the real world and answers the "why" behind many data-structuring decisions: Why use a hash table? Why is a set useful? Why avoid arrays? When you're finished with the course, you'll have a clear understanding of data structures and understand how to use them in whatever language you're programming in, today or 5 years from now.
- What is a data structure?
- Using C-style structs and arrays
- Sorting and searching arrays
- Working with singly and doubly linked lists
- Using stacks for last-in, first-out (LIFO) structures
- Using queues for first-in, first-out (FIFO) structures
- Working with hash tables
- Understanding binary search trees (BSTs)
- Learning about graphs