From 0 to 1: Data Structures & Algorithms in Java
4.2 (354 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
3,623 students enrolled
Wishlisted Wishlist

Please confirm that you want to add From 0 to 1: Data Structures & Algorithms in Java to your Wishlist.

Add to Wishlist

From 0 to 1: Data Structures & Algorithms in Java

Learn so you can see it with your eyes closed
4.2 (354 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
3,623 students enrolled
Created by Loony Corn
Last updated 7/2016
English
Current price: $10 Original price: $50 Discount: 80% off
1 day left at this price!
30-Day Money-Back Guarantee
Includes:
  • 15 hours on-demand video
  • 115 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • 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
View Curriculum
Requirements
  • Basic knowledge of programming is assumed, preferably in Java
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 and Graph Algorithms
  • Linked lists
  • Sorting
  • Searching


Using discussion forums

Please use the discussion forums on this course to engage with other students and to help each other out. Unfortunately, much as we would like to, it is not possible for us at Loonycorn to respond to individual questions from students:-(

We're super small and self-funded with only 2-3 people developing technical video content. Our mission is to make high-quality courses available at super low prices.

The only way to keep our prices this low is to *NOT offer additional technical support over email or in-person*. The truth is, direct support is hugely expensive and just does not scale.

We understand that this is not ideal and that a lot of students might benefit from this additional support. Hiring resources for additional support would make our offering much more expensive, thus defeating our original purpose.

It is a hard trade-off.

Thank you for your patience and understanding!


Who 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
Students Who Viewed This Course Also Viewed
Curriculum For This Course
67 Lectures
15:01:21
+
What this course is about
1 Lecture 03:02

A short intro to this course and what you can expect at the end of the course.

Preview 03:02
+
Data Structures And Algorithms - A Symbiotic Relationship
1 Lecture 15:04

Data structures and Algorithms have a symbiotic relationship. The choice of data structure significantly influences the algorithms' performance and complexity and vice versa. Also learn about abstract data types and how they relate to data structures.

Preview 15:04
+
Complexity Analysis and the Big-O Notation
3 Lectures 52:01

What is the performance of your code? How do you measure this? What is complexity and what is its relationship with performance?

Performance and Complexity
16:02

The Big O notation is used to express complexity based on the size of the input specified for any algorithm. How is Big O expressed, how is it calculated and many examples to drive the concepts home!
The Big-O Notation
16:46

The Big O notation becomes much clearer when you practice find the complexity of some sample pieces of code. Let's see how many of these you get right!

What is the complexity of these pieces of code?
19:13
+
Linked Lists
3 Lectures 40:47

Linked lists are just one way to implement lists. Linked lists are less interesting in Java then in other programming languages such as C and C++ which require the developer to manage memory.

However lists are useful and a very core data structure so it makes sense to start off this class by understanding how we can set up a linked list in Java.

The Linked List - The Most Basic Of All Data Structures
19:55

A few basic problems working with lists should give you a good idea of how to traverse and linked lists, add elements to a list and count the number of elements in a list.

The source code attached to this lecture has solutions for even more linked list based problems which are not covered in this lecture.

Preview 10:25

Linked lists and arrays solve the same kind of problems, holding a list or a collection. When would you use one over the other? Learn how you can make an informed choice.

Linked Lists vs Arrays
10:27
+
Stacks And Queues
7 Lectures 01:44:10

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.

Preview 15:40

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.

Building A Stack Using Java
16:53

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.

Match Parenthesis To Check A Well Formed Expression
11:21

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?

Find The Minimum Element In A Stack In Constant Time
08:51

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.

Meet The Queue - A Familiar Sight In Everyday Life
14:11

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.

The Circular Queue - Tricky But Fast
19:44

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.

Build A Queue With Two Stacks
17:30
+
Sorting and Searching
8 Lectures 01:56:21
A sorting algorithm is not just defined by its complexity, there are a whole bunch of other characteristics which can be used to determine which sorting algorithm is the right one for a system. Let's understand what these characteristics are and what are the trade offs we might make.
Preview 10:52

The simplest and most naive sorting algorithm.

Selection Sort
15:24

Closely allied with selection sort is bubble sort. Its an adaptive sort with the same time complexity as selection sort.
Bubble Sort
14:42

Insertion sort is an improvement over both bubble sort and selection sort. Let's see how exactly it works and why it's preferred in many cases.
Insertion Sort
14:32

Shell sort builds on top of insertion sort, it improves the complexity of it's running time by partitioning the list in a clever way.
Shell Sort
14:24

This belongs to a class of algorithms which uses divide and conquer to break the problem set into smaller pieces. This also makes a time-space trade off to get a faster running time.

Merge Sort
19:23

Quick sort is the sort of choice for developers of programming libraries. Let's see what makes it so attractive.
Quick Sort
15:30

Binary search is a pretty nifty way to search through a sorted list in O(Log N) time. It's also an interview favorite so make sure you understand it well!

Binary Search - search quickly through a sorted list
11:34
+
Binary Trees
4 Lectures 01:00:12

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.

Preview 13:03

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.

Breadth First Traversal
18:43

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 sub-trees. Pre-order traversal processes the node before processing the left and then the right sub trees.

Depth First - Pre-OrderTraversal
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 sub-trees.

In-order traversal processes the left subtree, then the node itself and then it's right sub trees. Post-order traversal processes the node *after* it's left and right subtrees.

The algorithms are all remarkably similar and very easy once you use recursion.

Depth First - In-Order and Post-Order Traversal
13:51
+
Binary Search Trees
2 Lectures 26: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
The Binary Search Tree - an introduction
09:49

Insertion and Lookup are operations which are very fast in a Binary Search Tree. See how they work and understand their performance and complexity.
Insertion and Lookup in a Binary Search Tree
17:00
+
Binary Tree Problems
2 Lectures 26:53

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.

Minimum Value, Maximum Depth And Mirror
12:14

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.
Count Trees, Print Range and Is BST
14:39
+
Heaps
6 Lectures 01:30:51

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.

Preview 17:15

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.

Meet The Binary Heap - It's A Tree At Heart
12:39

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.

The Binary Heap - Logically A Tree Really An Array
17:13

Let's build a real heap in Java!

The Binary Heap - Making It Real With Code
07:38

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.

Heapify!
19:32

Once we understand heapify, adding and removing elements from a heap become very simple.

Insert And Remove From A Heap
16:34
7 More Sections
About the Instructor
Loony Corn
4.3 Average rating
4,276 Reviews
32,547 Students
75 Courses
An ex-Google, Stanford and Flipkart team

Loonycorn is us, Janani Ravi and Vitthal Srinivasan. Between us, we have studied at Stanford, been admitted to IIM Ahmedabad and have spent years  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

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 :-)