Data Structures & Algorithms in Java : From 0 to 1

About Course

• 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 you will 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
  • Big-O notation and complexity
  • Stacks
  • Queues
  • Trees
  • Heaps
  • Graphs
  • Linked lists
  • Sorting
  • Searching

Topics covered in this course

• 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 Preview	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 Preview	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 Preview	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

Who should buy this course?

• • Basic knowledge of programming is assumed, preferably in Java
  • Computer Science and Engineering grads who are looking to really visualise data structures, and internalise how they work
  • Experienced software engineers who are looking to refresh important fundamental concepts