From 0 to 1: Data Structures & Algorithms in Java

Course Curriculum

Chapter 1: What this course is about

Lecture 1: You, This course and Us

Chapter 2: Data Structures And Algorithms – A Symbiotic Relationship

Lecture 1: Why are Data Structures And Algorithms important?

Chapter 3: Complexity Analysis and the Big-O Notation

Lecture 1: Performance and Complexity

Lecture 2: The Big-O Notation

Lecture 3: What is the complexity of these pieces of code?

Chapter 4: Linked Lists

Lecture 1: The Linked List – The Most Basic Of All Data Structures

Lecture 2: Linked List Problems

Lecture 3: Linked Lists vs Arrays

Chapter 5: Stacks And Queues

Lecture 1: Meet The Stack – Simple But Powerful

Lecture 2: Building A Stack Using Java

Lecture 3: Match Parenthesis To Check A Well Formed Expression

Lecture 4: Find The Minimum Element In A Stack In Constant Time

Lecture 5: Meet The Queue – A Familiar Sight In Everyday Life

Lecture 6: The Circular Queue – Tricky But Fast

Lecture 7: Build A Queue With Two Stacks

Chapter 6: Sorting and Searching

Lecture 1: Sorting Trade-Offs

Lecture 2: Selection Sort

Lecture 3: Bubble Sort

Lecture 4: Insertion Sort

Lecture 5: Shell Sort

Lecture 6: Merge Sort

Lecture 7: Quick Sort

Lecture 8: Binary Search – search quickly through a sorted list

Chapter 7: Binary Trees

Lecture 1: Meet The Binary Tree – A Hierarchical Data Structure

Lecture 2: Breadth First Traversal

Lecture 3: Depth First – Pre-OrderTraversal

Lecture 4: Depth First – In-Order and Post-Order Traversal

Chapter 8: Binary Search Trees

Lecture 1: The Binary Search Tree – an introduction

Lecture 2: Insertion and Lookup in a Binary Search Tree

Chapter 9: Binary Tree Problems

Lecture 1: Minimum Value, Maximum Depth And Mirror

Lecture 2: Count Trees, Print Range and Is BST

Chapter 10: Heaps

Lecture 1: The Heap Is Just The Best Way to Implement a Priority Queue

Lecture 2: Meet The Binary Heap – It's A Tree At Heart

Lecture 3: The Binary Heap – Logically A Tree Really An Array

Lecture 4: The Binary Heap – Making It Real With Code

Lecture 5: Heapify!

Lecture 6: Insert And Remove From A Heap

Chapter 11: Revisiting Sorting – The Heap Sort

Lecture 1: Heap Sort Phase I – Heapify

Lecture 2: Heap Sort Phase II – The Actual Sort

Chapter 12: Heap Problems

Lecture 1: Maximum Element In A Minimum Heap and K Largest Elements In A Stream

Chapter 13: Graphs

Lecture 1: Introducing The Graph

Lecture 2: Types Of Graphs

Lecture 3: The Directed And Undirected Graph

Lecture 4: Representing A Graph In Code

Lecture 5: Graph Using An Adjacency Matrix

Lecture 6: Graph Using An Adjacency List And Adjacency Set

Lecture 7: Comparison Of Graph Representations

Lecture 8: Graph Traversal – Depth First And Breadth First

Chapter 14: Graph Algorithms

Lecture 1: Topological Sort In A Graph

Lecture 2: Implementation Of Topological Sort

Chapter 15: Shortest Path Algorithms

Lecture 1: Introduction To Shortest Path In An Unweighted Graph – The Distance Table

Lecture 2: The Shortest Path Algorithm Visualized

Lecture 3: Implementation Of The Shortest Path In An Unweighted Graph

Lecture 4: Introduction To The Weighted Graph

Lecture 5: Shortest Path In A Weighted Graph – A Greedy Algorithm

Lecture 6: Dijkstra's Algorithm Visualized

Lecture 7: Implementation Of Dijkstra's Algorithm

Lecture 8: Introduction To The Bellman Ford Algorithm

Lecture 9: The Bellman Ford Algorithm Visualized

Lecture 10: Dealing With Negative Cycles In The Bellman Ford Algorithm

Lecture 11: Implementation Of The Bellman Ford Algorithm

Chapter 16: Spanning Tree Algorithms

Lecture 1: Prim's Algorithm For a Minimal Spanning Tree

Lecture 2: Use Cases And Implementation Of Prim's Algorithm

Lecture 3: Kruskal's Algorithm For a Minimal Spanning Tree

Lecture 4: Implementation Of Kruskal's Algorithm

Chapter 17: Graph Problems

Lecture 1: Design A Course Schedule Considering Pre-reqs For Courses

Lecture 2: Find The Shortest Path In A Weighted Graphs – Fewer Edges Better