# 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.*

## 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