From 0 to 1: Data Structures & Algorithms in Java

S$30.00
Take This Course
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:

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

Curriculum

Section 1: What this course is about
You, This course and Us
03:02
Section 2: Data Structures And Algorithms – A Symbiotic Relationship
Why are Data Structures And Algorithms important?
15:04
Section 3: Complexity Analysis and the Big-O Notation
Performance and Complexity
16:02
The Big-O Notation
16:46
What is the complexity of these pieces of code?
19:13
Section 4: Linked Lists
The Linked List – The Most Basic Of All Data Structures
19:55
Linked List Problems
10:25
Linked Lists vs Arrays
10:27
Section 5: Stacks And Queues
Meet The Stack – Simple But Powerful
15:40
Building A Stack Using Java
16:53
Match Parenthesis To Check A Well Formed Expression
11:21
Find The Minimum Element In A Stack In Constant Time
08:51
Meet The Queue – A Familiar Sight In Everyday Life
14:11
The Circular Queue – Tricky But Fast
19:44
Build A Queue With Two Stacks
17:30
Section 6: Sorting and Searching
Sorting Trade-Offs
10:52
Selection Sort
15:24
Bubble Sort
14:42
Insertion Sort
14:32
Shell Sort
14:24
Merge Sort
19:23
Quick Sort
15:30
Binary Search – search quickly through a sorted list
11:34
Section 7: Binary Trees
Meet The Binary Tree – A Hierarchical Data Structure
13:03
Breadth First Traversal
18:43
Depth First – Pre-OrderTraversal
14:35
Depth First – In-Order and Post-Order Traversal
13:51
Section 8: Binary Search Trees
The Binary Search Tree – an introduction
09:49
Insertion and Lookup in a Binary Search Tree
17:00
Section 9: Binary Tree Problems
Minimum Value, Maximum Depth And Mirror
12:14
Count Trees, Print Range and Is BST
14:39
Section 10: Heaps
The Heap Is Just The Best Way to Implement a Priority Queue
17:15
Meet The Binary Heap – It’s A Tree At Heart
12:39
The Binary Heap – Logically A Tree Really An Array
17:13
The Binary Heap – Making It Real With Code
07:38
Heapify!
19:32
Insert And Remove From A Heap
16:34
Section 11: Revisiting Sorting – The Heap Sort
Heap Sort Phase I – Heapify
19:31
Heap Sort Phase II – The Actual Sort
17:42
Section 12: Heap Problems
Maximum Element In A Minimum Heap and K Largest Elements In A Stream
15:54
Section 13: Graphs
Introducing The Graph
15:40
Types Of Graphs
07:21
The Directed And Undirected Graph
14:29
Representing A Graph In Code
08:09
Graph Using An Adjacency Matrix
15:25
Graph Using An Adjacency List And Adjacency Set
17:53
Comparison Of Graph Representations
10:08
Graph Traversal – Depth First And Breadth First
14:56
Section 14: Graph Algorithms
Topological Sort In A Graph
17:30
Implementation Of Topological Sort
06:56
Section 15: Shortest Path Algorithms
Introduction To Shortest Path In An Unweighted Graph – The Distance Table
12:38
The Shortest Path Algorithm Visualized
14:15
Implementation Of The Shortest Path In An Unweighted Graph
06:19
Introduction To The Weighted Graph
03:29
Shortest Path In A Weighted Graph – A Greedy Algorithm
18:47
Dijkstra’s Algorithm Visualized
14:14
Implementation Of Dijkstra’s Algorithm
08:15
Introduction To The Bellman Ford Algorithm
08:40
The Bellman Ford Algorithm Visualized
11:22
Dealing With Negative Cycles In The Bellman Ford Algorithm
07:36
Implementation Of The Bellman Ford Algorithm
06:54
Section 16: Spanning Tree Algorithms
Prim’s Algorithm For a Minimal Spanning Tree
17:27
Use Cases And Implementation Of Prim’s Algorithm
09:52
Kruskal’s Algorithm For a Minimal Spanning Tree
08:43
Implementation Of Kruskal’s Algorithm
07:34
Section 17: Graph Problems
Design A Course Schedule Considering Pre-reqs For Courses
13:01
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 🙂

Course Features

  • Lectures
    Fatal error: Uncaught Error: Call to undefined method LP_Course::get_lessons() in /home2/waf6oo0adwwo/public_html/wp-content/themes/eduma/inc/learnpress-v2-functions.php:624 Stack trace: #0 /home2/waf6oo0adwwo/public_html/wp-content/themes/eduma/learnpress-v2/single-course/content-landing.php(64): thim_course_info() #1 /home2/waf6oo0adwwo/public_html/wp-content/plugins/learnpress/inc/lp-template-functions.php(2492): include('/home2/waf6oo0a...') #2 /home2/waf6oo0adwwo/public_html/wp-content/themes/eduma/learnpress-v2/content-single-course.php(65): learn_press_get_template('single-course/c...', Array) #3 /home2/waf6oo0adwwo/public_html/wp-content/plugins/learnpress/inc/lp-template-functions.php(2492): include('/home2/waf6oo0a...') #4 /home2/waf6oo0adwwo/public_html/wp-content/plugins/learnpress/inc/lp-template-functions.php(1563): learn_press_get_template('content-single-...') #5 /home2/waf6oo0adwwo/public_html/wp-includes/class-wp-hook.php(286): learn_press_content_single_course('') #6 /home2/waf6oo0adwwo/public_html/wp-i in /home2/waf6oo0adwwo/public_html/wp-content/themes/eduma/inc/learnpress-v2-functions.php on line 624