• LOGIN
  • No products in the basket.

1 STUDENTS ENROLLED

Course Curriculum

Section 01: What this course is about
You, This course and Us 00:02:09
Section 02: Data Structures And Algorithms - A Symbiotic Relationship
Why are Data Structures And Algorithms important? FREE 00: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.
Section 03: Complexity Analysis and the Big-O Notation
Performance and Complexity 00:16:02
What is the performance of your code? How do you measure this? What is complexity and what is its relationship with performance?
The Big-O Notation 00:16:46
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!
What is the complexity of these pieces of code? 00:19:13
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!
Section 04: Linked Lists
Linked Lists And Their Memory Representation 00:17:16
Linked lists are favorite interview questions for software engineering roles. Linked lists are also a very basic and interesting data structure. If you can work linked lists you're on your way to tackling more complicated problems. Understand the memory set up of linked lists and start with a few problems to gain confidence. Get the length of a linked list, access the nth element in a list, and append an element to the end of the list - all this while handling null lists and other details.
The Doubly Linked List FREE 00:09:04
The doubly linked list is a variation on the linked list, it has pointers to both the next and the previous elements and optimizes some of the pain points when dealing with regular linked lists.
Linked Lists vs Arrays 00:10:27
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.
Section 05: Stacks And Queues
Meet The Stack – Simple But Powerful 00: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.
Building A Stack Using Java 00: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.
Match Parenthesis To Check A Well Formed Expression 00: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.
Find The Minimum Element In A Stack In Constant Time 00: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?
Meet The Queue – A Familiar Sight In Everyday Life 00: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.
The Circular Queue – Tricky But Fast 00: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.
Build A Queue With Two Stacks 00: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 06: Sorting and Searching
Sorting Trade-Offs FREE 00:10:52
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.
Selection Sort 00:15:24
The simplest and most naive sorting algorithm.
Bubble Sort 00:14:42
Closely allied with selection sort is bubble sort. Its an adaptive sort with the same time complexity as selection sort.
Insertion Sort 00:14:32
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.
Shell Sort 00:14:24
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.
Merge Sort 00:19:23
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.
Quick Sort 00:15:24
Quick sort is the sort of choice for developers of programming libraries. Let's see what makes it so attractive.
Binary Search – search quickly through a sorted list 00:11:34
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!
Section 07: Binary Trees
Meet The Binary Tree – A Hierarchical Data Structure 00: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.
Breadth First Traversal 00: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.
Depth First – Pre-OrderTraversal 00: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. Pre-order traversal processes the node before processing the left and then the right sub trees.
Depth First – In-Order and Post-Order Traversal 00: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 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.
Section 08: Binary Search Trees
The Binary Search Tree – an introduction FREE 00: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.
Insertion and Lookup in a Binary Search Tree 00: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 09: Binary Tree Problems
Minimum Value, Maximum Depth and Mirror 00: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.
Count Trees, Print Range and Is BST 00:14:38
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.
Section 10: Heaps
The Heap Is Just The Best Way to Implement a Priority Queue 00: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.
Meet The Binary Heap – It’s A Tree At Heart 00: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.
The Binary Heap – Logically A Tree Really An Array 00: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.
The Binary Heap – Making It Real With Code 00:08:58
Let's build a real heap in Java!
Heapify! 00: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.
Insert And Remove From A Heap 00:16:34
Once we understand heapify, adding and removing elements from a heap become very simple.
Section 11: Revisiting Sorting - The Heap Sort
Heap Sort Phase I – Heapify 00:19:31
Back to sorting. The Heap Sort uses a heap to transform an unsorted array into a sorted array. Phase I is converting the unsorted array into a heap.
Heap Sort Phase II – The Actual Sort 00:17:42
Phase II actually outputs the final sorted array. It involves removing the elements from the heap and placing it in a sorted array. The cool thing is that all of this can be done in-place.
Section 12: Heap Problems
Maximum Element In A Minimum Heap and K Largest Elements In A Stream 00:15:54
Let's practice heap problems! Use the heap property to find the largest element in a minimum heap and the K largest elements in a stream.
Section 13: Graphs
Introducing The Graph 00:15:40
The graph is a data structure that is used to model a very large number of real world problems. It's also an programming interview favorite. The study of graphs and algorithms associated with graphs forms an entire field of study called graph theory.
Types Of Graphs FREE 00:07:21
Edges in a graph can be directed or undirected. A graph with directed edges forms a Directed Graph and those with undirected edges forms an Undirected Graph. These edges can be likened to one-way and two-way streets.
The Directed And Undirected Graph 00:14:29
Different relationships can be modeled using either Directed or Undirected graphs. When a graph has no cycles it's called an acyclic graph. A graph with no cycles is basically a tree.
Representing A Graph In Code 00:08:09
There are a number of different ways in which graphs can be implemented. However they all follow they same basic graph interface. The graph interface allows building up a graph by adding edges and traversing a graph by giving access to all adjacent vertices of any vertex.
Graph Using An Adjacency Matrix 00:15:25
An adjacency matrix is one way in which a graph can be represented. The graph vertices are rows and columns of the matrix and the cell value shows the relationship between the vertices of a graph.
Graph Using An Adjacency List And Adjacency Set 00:17:53
The adjacency list and the adjacency set are alternate ways to represent a graph. Here the connection between the vertices is represented using either a linked list or a set.
Comparison Of Graph Representations 00:10:08
Compare the adjacency matrix, adjacency list and the adjacency set in terms of space and time complexity of common operations
Graph Traversal – Depth First And Breadth First 00:14:56
Common traversal methods of trees apply to graphs as well. There is an additional wrinkle with graphs, dealing with cycles and with unconnected graphs. Otherwise the algorithms are exactly the same as those we use to traverse trees.
© 2016. LearnBox Education.

Login

Register

Create an Account
Create an Account Back to login/register