Skip to main content

Data Structures Primer

I've been a tutor for this past semester to students taking Introduction to Programming. Many who have come to my session are moving on to Data Structures next semester. They asked if they could have a primer as to what to expect.

I have some resources that I have found helpful both while taking the course and tutoring it in the past. It will take me a little bit to compile a good list of those, but for now, here is a bare-bones list of topics of topics you might expect to see for a data structures course:

Part 1:
- Running time of code segments (Big-O Notation)
- Abstract Data Type (ADT)
- Interfaces (when to use "implements", cannot instantiate them, what inheritance is)
- Superclass, subclass, method overriding/overloading
- Abstract classes

Part 2:
- Binary Search Trees
- Stacks (and its four methods — push, pop, peek, empty)
- Linked list (single, double, circular)
- Prefix and postfix notation (compare to infix)

Part 3:
- Min/Max Heap
- Hash Tables - Open and closed hashing. How to insert into a hash table given a probe sequence.
- Binary Trees (AVL and Red/BLack)
- AVL Trees - how to construct one, worst case AVL-tree
- Red Black Trees
- B-Trees, especially deletion from one
- Know recursive code and how to trace it

Bear in mind, this is an incomplete list. The topics may be presented in different order as well. The "parts" are how I remember it and might not be accurate.

I'm not sure if I'll be able to compile a complete list of resources, but here is probably the best one for visualizing data structures: https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

Another one is CodingBat.com/java. This is especially helpful for learning recursive code. I don't know if any of the other sections would be helpful, but they might be.

Best of luck! It will be tough, but you got it! Even if you know one or two topics from each part, you will have a leg up on learning this material.

Comments

Popular posts from this blog

Apprenticeship Pattern “Practice, Practice, Practice”

The apprenticeship pattern framed the problem is that if you do not have room to make mistakes in your day to day programming, you will not have room to grow. The next line hit close to home, “It’s as if you’re always on stage.” I learn quite a bit from my school assignments, but I don’t always think I have mastered each area before moving on to the next topic. The problem arises when I know my code could be improved upon, but it’s currently working. I don’t want to restructure my code too much, because I’m afraid of making it worse. The term comes to mind, “If it ain’t broke don’t fix it.” I have problems with this way of thinking, but when you’re pressed to make something work before the impending deadline, “good enough” is sometimes feels like the only option I have left. This pattern champions a different approach to this kind of mentality. I like the idealized version that they have laid out based on the research of K. Anders Ericsson. This describes where a mentor would ass...