From 0 to 1: Data Structures & Algorithms in Java
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:
BigO 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
Curriculum
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 BigO Notation  
Lecture 3 
Performance and Complexity

16:02  
Lecture 4 
The BigO 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 TradeOffs

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 – PreOrderTraversal

14:35  
Lecture 27 
Depth First – InOrder and PostOrder 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 Prereqs For Courses

13:01  
Lecture 67 
Find The Shortest Path In A Weighted Graphs – Fewer Edges Better

14:31 
Instructor Biography
Loony Corn, A 4person team;exGoogle; 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 ðŸ™‚
Course Features
 Lectures 0
 Quizzes 0
 Duration 50 hours
 Skill level All level
 Language English
 Students 1952
 Assessments Self