Course Description
This is an animated, visual and spatial way to learn data structures and algorithms
Our brains process different types of information differently – evolutionarily we are wired to absorb information best when it is visual and spatial i.e. when we can close our eyes and see it
More than most other concepts, Data Structures and Algorithms are best learnt visually. These are incredibly easy to learn visually, very hard to understand most other ways
This course has been put together by a team with tons of everyday experience in thinking about these concepts and using them at work at Google, Microsoft and Flipkart
What’s Covered:
Big-O notation and complexity
Stacks
Queues
Trees
Heaps
Graphs
Linked lists
Sorting
Searching
Talk to us!
Mail us about anything – anything! – and we will always reply 🙂
What are the requirements?
Basic knowledge of programming is assumed, preferably in Java
What am I going to get from this course?
Visualise – really vividly imagine – the common data structures, and the algorithms applied to them
Pick the correct tool for the job – correctly identify which data structure or algorithm makes sense in a particular situation
Calculate the time and space complexity of code – really understand the nuances of the performance aspects of code
What is the target audience?
Yep! Computer Science and Engineering grads who are looking to really visualise data structures, and internalise how they work
Yep! Experienced software engineers who are looking to refresh important fundamental concepts
| Section 1: What this course is about | |||
|---|---|---|---|
| Lecture 1 |
You, This course and Us
|
03:02 | |
| Section 2: Data Structures And Algorithms – A Symbiotic Relationship | |||
| Lecture 2 |
Why are Data Structures And Algorithms important?
|
15:04 | |
| Section 3: Complexity Analysis and the Big-O Notation | |||
| Lecture 3 |
Performance and Complexity
|
16:02 | |
| Lecture 4 |
The Big-O Notation
|
16:46 | |
| Lecture 5 |
What is the complexity of these pieces of code?
|
19:13 | |
| Section 4: Linked Lists | |||
| Lecture 6 |
The Linked List – The Most Basic Of All Data Structures
|
19:55 | |
| Lecture 7 |
Linked List Problems
|
10:25 | |
| Lecture 8 |
Linked Lists vs Arrays
|
10:27 | |
| Section 5: Stacks And Queues | |||
| Lecture 9 |
Meet The Stack – Simple But Powerful
|
15:40 | |
| Lecture 10 |
Building A Stack Using Java
|
16:53 | |
| Lecture 11 |
Match Parenthesis To Check A Well Formed Expression
|
11:21 | |
| Lecture 12 |
Find The Minimum Element In A Stack In Constant Time
|
08:51 | |
| Lecture 13 |
Meet The Queue – A Familiar Sight In Everyday Life
|
14:11 | |
| Lecture 14 |
The Circular Queue – Tricky But Fast
|
19:44 | |
| Lecture 15 |
Build A Queue With Two Stacks
|
17:30 | |
| Section 6: Sorting and Searching | |||
| Lecture 16 |
Sorting Trade-Offs
|
10:52 | |
| Lecture 17 |
Selection Sort
|
15:24 | |
| Lecture 18 |
Bubble Sort
|
14:42 | |
| Lecture 19 |
Insertion Sort
|
14:32 | |
| Lecture 20 |
Shell Sort
|
14:24 | |
| Lecture 21 |
Merge Sort
|
19:23 | |
| Lecture 22 |
Quick Sort
|
15:30 | |
| Lecture 23 |
Binary Search – search quickly through a sorted list
|
11:34 | |
| Section 7: Binary Trees | |||
| Lecture 24 |
Meet The Binary Tree – A Hierarchical Data Structure
|
13:03 | |
| Lecture 25 |
Breadth First Traversal
|
18:43 | |
| Lecture 26 |
Depth First – Pre-OrderTraversal
|
14:35 | |
| Lecture 27 |
Depth First – In-Order and Post-Order Traversal
|
13:51 | |
| Section 8: Binary Search Trees | |||
| Lecture 28 |
The Binary Search Tree – an introduction
|
09:49 | |
| Lecture 29 |
Insertion and Lookup in a Binary Search Tree
|
17:00 | |
| Section 9: Binary Tree Problems | |||
| Lecture 30 |
Minimum Value, Maximum Depth And Mirror
|
12:14 | |
| Lecture 31 |
Count Trees, Print Range and Is BST
|
14:39 | |
| Section 10: Heaps | |||
| Lecture 32 |
The Heap Is Just The Best Way to Implement a Priority Queue
|
17:15 | |
| Lecture 33 |
Meet The Binary Heap – It’s A Tree At Heart
|
12:39 | |
| Lecture 34 |
The Binary Heap – Logically A Tree Really An Array
|
17:13 | |
| Lecture 35 |
The Binary Heap – Making It Real With Code
|
07:38 | |
| Lecture 36 |
Heapify!
|
19:32 | |
| Lecture 37 |
Insert And Remove From A Heap
|
16:34 | |
| Section 11: Revisiting Sorting – The Heap Sort | |||
| Lecture 38 |
Heap Sort Phase I – Heapify
|
19:31 | |
| Lecture 39 |
Heap Sort Phase II – The Actual Sort
|
17:42 | |
| Section 12: Heap Problems | |||
| Lecture 40 |
Maximum Element In A Minimum Heap and K Largest Elements In A Stream
|
15:54 | |
| Section 13: Graphs | |||
| Lecture 41 |
Introducing The Graph
|
15:40 | |
| Lecture 42 |
Types Of Graphs
|
07:21 | |
| Lecture 43 |
The Directed And Undirected Graph
|
14:29 | |
| Lecture 44 |
Representing A Graph In Code
|
08:09 | |
| Lecture 45 |
Graph Using An Adjacency Matrix
|
15:25 | |
| Lecture 46 |
Graph Using An Adjacency List And Adjacency Set
|
17:53 | |
| Lecture 47 |
Comparison Of Graph Representations
|
10:08 | |
| Lecture 48 |
Graph Traversal – Depth First And Breadth First
|
14:56 | |
| Section 14: Graph Algorithms | |||
| Lecture 49 |
Topological Sort In A Graph
|
17:30 | |
| Lecture 50 |
Implementation Of Topological Sort
|
06:56 | |
| Section 15: Shortest Path Algorithms | |||
| Lecture 51 |
Introduction To Shortest Path In An Unweighted Graph – The Distance Table
|
12:38 | |
| Lecture 52 |
The Shortest Path Algorithm Visualized
|
14:15 | |
| Lecture 53 |
Implementation Of The Shortest Path In An Unweighted Graph
|
06:19 | |
| Lecture 54 |
Introduction To The Weighted Graph
|
03:29 | |
| Lecture 55 |
Shortest Path In A Weighted Graph – A Greedy Algorithm
|
18:47 | |
| Lecture 56 |
Dijkstra’s Algorithm Visualized
|
14:14 | |
| Lecture 57 |
Implementation Of Dijkstra’s Algorithm
|
08:15 | |
| Lecture 58 |
Introduction To The Bellman Ford Algorithm
|
08:40 | |
| Lecture 59 |
The Bellman Ford Algorithm Visualized
|
11:22 | |
| Lecture 60 |
Dealing With Negative Cycles In The Bellman Ford Algorithm
|
07:36 | |
| Lecture 61 |
Implementation Of The Bellman Ford Algorithm
|
06:54 | |
| Section 16: Spanning Tree Algorithms | |||
| Lecture 62 |
Prim’s Algorithm For a Minimal Spanning Tree
|
17:27 | |
| Lecture 63 |
Use Cases And Implementation Of Prim’s Algorithm
|
09:52 | |
| Lecture 64 |
Kruskal’s Algorithm For a Minimal Spanning Tree
|
08:43 | |
| Lecture 65 |
Implementation Of Kruskal’s Algorithm
|
07:34 | |
| Section 17: Graph Problems | |||
| Lecture 66 |
Design A Course Schedule Considering Pre-reqs For Courses
|
13:01 | |
| Lecture 67 |
Find The Shortest Path In A Weighted Graphs – Fewer Edges Better
|
14:31 | |
Instructor Biography
Loony Corn, A 4-person team;ex-Google; Stanford, IIM Ahmedabad, IIT
Loonycorn is us, Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh. Between the four of us, we have studied at Stanford, IIM Ahmedabad, the IITs and have spent years (decades, actually) working in tech, in the Bay Area, New York, Singapore and Bangalore.
Janani: 7 years at Google (New York, Singapore); Studied at Stanford; also worked at Flipkart and Microsoft
Vitthal: Also Google (Singapore) and studied at Stanford; Flipkart, Credit Suisse and INSEAD too
Swetha: Early Flipkart employee, IIM Ahmedabad and IIT Madras alum
Navdeep: longtime Flipkart employee too, and IIT Guwahati alum
We think we might have hit upon a neat way of teaching complicated tech courses in a funny, practical, engaging way, which is why we are so excited to be here on Udemy!
We hope you will try our offerings, and think you’ll like them 🙂