Find online courses made by experts from around the world.
Take your courses with you and learn anywhere, anytime.
Learn and practice realworld skills and achieve your goals.
Note: This course is a subset of our much longer course 'From 0 to 1: Data Structures & Algorithms' so please don't sign up for both:)
This is an animated, visual and spatial way to learn data structures and algorithms
What's Covered:
Talk to us!
Mail us about anything  anything!  and we will always reply :)
Not for you? No problem.
30 day money back guarantee.
Forever yours.
Lifetime access.
Learn on the go.
Desktop, iOS and Android.
Get rewarded.
Certificate of completion.
Section 1: Strong Fundamentals: Data Structures!  

Lecture 1 
You, This Course, and Us!
Preview

01:09  
Lecture 2  15:40  
The stack is a very simple and easy to understand data structure. However it lies underneath many complicated real world problems and is incredibly useful.  
Lecture 3  16:53  
Let's build a stack for real using Java. It'll have all the operations we're interested in  push, pop, peek, size etc. It can hold any data type, it's a generic class.  
Lecture 4  11:21  
Problems which use stacks as a part of their solutions are very common in programming interviews. Matching parenthesis to check for well formed expressions is a classic interview question  let's solve this using the stack we're already implemented.  
Lecture 5  08:51  
Another interview question implemented. You have space available but your processing needs to be very fast indeed. How would you keep track of the minimum element of a stack as it changes?  
Lecture 6  14:11  
The queue belongs to the same linear data structure family as the stack but it's behavior is very different. Queues are much more intuitive as there are plenty of real world examples where a queue is the fair and correct way of processing. 

Lecture 7  19:44  
A common, fast but slightly tricky implementation of the queue is the array where the last element wraps around to the first. An interview favorite, let's see how to implement the circular queue.  
Lecture 8  17:30  
We know the stack, and we know the queue. This problem brings them together. It's possible to mimic the behavior of a queue using 2 stacks in the underlying implementation. Let's write the most efficient code possible to make this work. 

Section 2: Binary Trees  
Lecture 9  13:03  
The binary tree is an incredibly useful hierarchical data structure. Many other, more complex data structures, use the binary tree as the foundation. Let's see what a binary tree looks like and learn some simple terminology associated with the tree. 

Lecture 10  18:43  
Traversing a binary tree can be done in variety of ways. The breadth first traversal visits and processes nodes at every level before moving on to the next. Let's visualize breadth first traversal and see how it's implemented.  
Lecture 11  14:35  
Depth first traversal can be of 3 types based on the order in which the node is processed relative to it's left and right subtrees. Preorder traversal processes the node before processing the left and then the right sub trees. 

Lecture 12  13:51  
Depth first traversal can be of 3 types based on the order in which the node is processed relative to it's left and right subtrees. Inorder traversal processes the left subtree, then the node itself and then it's right sub trees. Postorder traversal processes the node *after* it's left and right subtrees. The algorithms are all remarkably similar and very easy once you use recursion. 

Section 3: Binary Search Trees  
Lecture 13  09:49  
A Binary Search Tree is a binary tree with specific constraints which make it very useful in certain operations. Learn what a BST is and how we can use it  
Lecture 14  17:00  
Insertion and Lookup are operations which are very fast in a Binary Search Tree. See how they work and understand their performance and complexity. 

Section 4: Binary Tree Problems  
Lecture 15  11:46  
Find the minimum value in a binary search tree, find the maximum depth of a binary tree and mirror a binary tree. Learn to solve these problems recursively and see implementation details. 

Lecture 16  14:39  
Count the number of structurally unique binary trees that can be built with N nodes, print the nodes within a certain range in a binary search tree and check whether a certain binary tree is a binary *search* tree. Learn to solve these problems and understand the implementation details.  
Lecture 17  14:49  
Check if a path from root node to leaf node has a specified sum, print all paths from the root node to all leaf nodes and find the least common ancestor for two nodes in a binary tree. Learn to solve these problems and understand the implementation details. 

Section 5: Heaps  
Lecture 18  17:15  
Priority Queues allow us to make decisions about which task or job has the highest priority and has to be processed first. Common operations on a Priority Queue are insertion, accessing the highest priority element and removing the highest priority element. The Binary Heap is the best implementation of the Priority Queue. 

Lecture 19  12:39  
The Binary Heap is logically a Binary Tree with specific constraints. Constraints exist on the value of a node with respect to it's children and on the shape of the tree. The heap property and the shape property determine whether a Binary Tree is really a Heap. 

Lecture 20  07:38  
Let's build a real heap in Java! 

Lecture 21  17:13  
The Binary Heap may logically be a tree, however the most efficient way to implement it is using an array. Real pointers from parent to child and from child to parent become implicit relationships on the indices of the array. 

Lecture 22  19:32  
How do we ensure that when we add an element or remove an element from an existing heap, that the heap property and shape property is maintained? This operation is called Heapify.  
Lecture 23  16:34  
Once we understand heapify, adding and removing elements from a heap become very simple. 
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 :)