Data Structures and Algorithms

Data Structures and Algorithms is an intermediate-level computer science course suitable for students who already have experience programming in C/C++. In this course, students will learn about and be able to implement a wide variety of data structures and algorithms as well as explore their space/time complexities and be able to understand when each are used in real-world contexts.

This course consists of 16 sessions and students are encouraged to take each session in consecutive order. Students will be learning a wide array of data structures and algorithms, including linked lists, AVL trees, bubble sort, and more.

Registration

Registration is currently closed as maximum capacity has been reached.

Notice: I am retired from teaching and mentoring, and this course is no longer active.

General Information

• This is an intermediate-level course and it is expected that students already have a grasp of basic C or C++ programming.
• There are optional practice assignments after nearly every session as well as optional projects ideally to be done throughout the course.
• Sessions consist of a mixture of lectures, whiteboards, Q+A, and demonstrations.
• Sessions can be expected to last 60-90 minutes each and are scheduled by appointment through Calendly (no Calendly registration required).
• Additional tutoring and help can be scheduled by appointment.

Full Course Overview

Session 1: Introduction

• Basic I/O
• Hello world!
• Compilers
• Makefiles
• Space/time complexity

Session 2: C++ Structures

• Defining structures
• Methods and constructors
• Creating structures
• Structure pointers
• Interacting with structures

Session 3: Linked Lists

• Singly linked lists
• Doubly linked lists
• Time complexity

Session 4: Queues

• Queues
• Time complexity

Session 5: Stacks

• Stacks
• Time complexity

Session 6: Binary Search Trees

• Binary search trees
• Time complexity

Session 7: B-Trees

• B-trees
• Time complexity

Session 8: AVL Trees

• AVL trees
• Time complexity

Session 9: Hash Tables

• Hash tables
• Time complexity

Session 10: Bubble Sort

• Bubble sort
• Time complexity
• Space complexity

Session 11: Selection Sort

• Selection sort
• Time complexity
• Space complexity

Session 12: Insertion Sort

• Insertion sort
• Time complexity
• Space complexity

Session 13: Merge Sort

• Merge sort
• Time complexity
• Space complexity

Session 14: Quicksort

• Quicksort
• Time complexity
• Space complexity

Session 15: Graphs I

• Graphs
• Vertices and edges
• Directed vs undirected
• Common implementations

Session 16: Graphs II

• Pathfinding algorithms
• Shortest path algorithms
• Dijkstra’s algorithm

Optional Practice Assignments

Implementation Practice: Data Structures

After each session covering a data structure, create an implementation of the discussed data structure. Your implementation may store any type of data you’d like, but it is recommended that you store integers.

Run experiments that measure the time complexities of each of the four basic operations: access, search, insertion, and deletion. Run multiple trials and with varying inputs to determine whether each operation runs in constant, linear, logarithmic, or other time.

Implementation Practice: Sorting Algorithms

After each session covering a sorting algorithm, create an implementation of the discussed algorithm. Your implementation may sort any type of data you’d like, but it is recommended that you sort integers.

Run experiments that measure the space/time taken by each algorithm. As you implement more sorting algorithms, compare their time complexities.

Optional Projects

Six Degrees of Separation

Model a real-life social network using a graph. Then, using any shortest path algorithm you’d like, find the shortest distance from any person A to any person B. Empirically prove the six degrees of separation.

More information about the six degrees of separation: Wikipedia / YouTube