educative.io

Data Structures in Python: An Interview Refresher (Coderust)


Introduction to Graphs - Solution Review: Implement Depth First Search This review provides a detailed analysis of the different ways to solve the Implement Breadth First Search challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5727060924301312). Introduction to Graphs - Solution Review: Check if a Graph is a Tree or Not This review provides a detailed analysis of the different ways to solve the Count the Number of Edges in Graph Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5719980670713856). Introduction to Graphs - Challenge 9: Remove Edge In this challenge, we will learn how to delete an edge between two vertices. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5710396451192832). Introduction to Hashing - The Hash Function This is the first building block of a hash table. Let's see how it works. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5758448008429568). Introduction to Trees - Skewed Binary Trees In this lesson, we will discuss another type of Binary Tree called Skewed Binary Tree. We will look at some of its properties and types. Introduction to Hashing - Solution Review: Trace the Complete Path of a Journey Have questions about Solution Review: Trace the Complete Path of a Journey? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5746196614217728). Introduction to Trees - Solution Review: Find the Height of a Binary Tree Have questions about Solution Review: Find the Height of a Binary Tree? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5714237762568192). Introduction to Trees - Binary Search Tree Insertion (Implementation) In this chapter, we’ll study the implementation of Binary Search Tree insertion in Python through the iterative and recursive approaches. Introduction to Complexity Measures - Example 2: Measuring Time Complexity Compute time complexity of a given algorithm with nested loops. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5731601040277504). Introduction to Lists - Solution Review: Right Rotate List This review provides a detailed analysis of the different ways to solve the Right Rotate List challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5701265350721536). Introduction to Linked Lists - Challenge 3: Deletion by Value Based on how we handled the deletion at head strategy, let’s write the function for deletion by value. Trie - Deletion in Trie After insertion and search, let’s figure out the logic behind deletion in tries. Introduction to Trees - What is an AVL Tree? This lesson is a brief introduction to AVL trees, why they are used, and what makes them more efficient than regular binary search trees. Introduction to Trees - 2-3 Insertion This lesson will explain how insertion is done in 2-3 Trees based on multiple scenarios which are explained in the insertion algorithm. Introduction to Trees - 2-3 Deletion (Case #2) How do we delete an element present at an internal node? It will be explained in this lesson with the help of an example. Trie - Search in a Trie This lesson defines the algorithm for a word search in a trie. It also highlights the different scenarios which are taken care of in the algorithm. Introduction to Graphs - What is a Bipartite Graph? Now, we’ll be introduced to a unique graph called the bipartite graph. We will also take a look at some examples to understand the concept better. Introduction to Graphs - Representation of Graphs Two approaches to represent a graph will be covered in this lesson. Introduction to Graphs - Graph Traversal Algorithms In this lesson, we will learn the basic logic behind graph traversal and we will see how it applies to the two most famous graph traversal algorithms. Introduction to Graphs - Challenge 1: Implement Breadth First Search Now, we shall build the BFS algorithm in Pythonic code. Trie - Challenge 3: List Sort Using Tries This lesson is about sorting string lists using tries. Trie - Structure of a Trie This lesson covers the structure of the Trie class in Python. Trie - What is a Trie? This lesson gives a brief introduction to Trie, its properties, and common applications. Introduction to Trees - 2-3-4 Trees This lesson is a brief introduction to 2-3-4 Trees. We will discuss its key features and take a look at its examples. Introduction to Trees - Solution Review: Find kth maximum value in Binary Search Tree Have questions about Solution Review: Find kth maximum value in Binary Search Tree? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5722608653828096). Introduction to Heap - What is a Heap? A brief introduction to Heaps and their uses. We will also discuss the Heap property and how a heap is implemented. Introduction to Heap - Min Heap: Introduction This lesson will give a brief introduction to Min-Heaps and how elements are inserted and removed from them Trie - Trie Quiz: Test Your Understanding of Tries We’re at the end of our discussion on tries. Here are a few follow up questions to reinforce your concepts. Introduction to Hashing - Challenge 4: Trace the Complete Path of a Journey Test your knowledge on hash table traversal with this coding exercise! Introduction to Heap - Max Heap (Implementation) Let’s implement a max Heap! Introduction to Trees - Overview of Trees A quick overview of trees, its types, and some important formulas to compute height and number of nodes in a tree. Introduction to Hashing - Challenge 2: Check if Lists are Disjoint Building upon the previous challenge, we will learn how to check if two sets are disjoint. Introduction to Hashing - Challenge 5: Find Two Pairs in List such that a+b = c+d If you are given a list, can you find two pairs such that their sum is equal? Summary of Data Structures - Overview of Linear & Non-Linear Data Structures In this lesson, we will have review time complexities of all the data structures we have studied. We will also categorize them into linear and non-linear data structures. Introduction to Heap - Challenge 2: Find k smallest elements in a List Given a list and a number “k” write a function that returns the first “k” smallest elements using a Heap? Introduction to Graphs - Solution Review: Remove Edge This review provides a detailed analysis of the different ways to solve the Remove Edge Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5124732563226624). Introduction to Linked Lists - Singly Linked List Insertion Let’s look at the Pythonic implementation for the insertion of a node in a linked list. Introduction to Hashing - Challenge 6: A Sublist with a Sum of 0 In this exercise, we will find a sublist whose sum turns out to be zero. Let’s try it out! Introduction to Complexity Measures - Complexity Measures This chapter will cover different types of complexity measures like Big O and their uses. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5695219446054912). Introduction to Stack/Queues - What is a Stack? An introduction to the Stack data structure, its uses and functionality. Introduction to Lists - Solution Review: Find Minimum Value in List This review provides a detailed analysis of the different ways to solve the find minimum value in list challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5734439678115840). Introduction to Linked Lists - Linked Lists vs. Arrays Let's pit the two data structures against each other to find out which is more efficient. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5696228427825152). Introduction to Lists - Lists vs Arrays in Python Have questions about Lists vs Arrays in Python? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5663311798468608). Introduction to Linked Lists - Solution Review: Search in a Singly Linked List This review provides a detailed analysis of the different ways to solve the Search in a Singly Linked List challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5679350280093696). Introduction to Linked Lists - Basic Linked List Operations This lesson lists the various operations that can be performed on linked lists View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5728526581891072). Introduction to Lists - Solution Review: First Non-Repeating Integer in a list This review provides a detailed analysis of the different ways to solve the First Non-Repeating Integer in a List challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5635792869261312). Introduction to Graphs - Solution Review: Find "Mother Vertex" in a Graph This review provides a detailed analysis of the different ways to solve the Find "Mother Vertex" in a Graph challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5703702744662016). Introduction to Graphs - Complexities of Graph Operations Let's discuss the performance of the two graph representation approaches. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5690373313658880). Introduction to Stack/Queues - Solution Review: Check Balanced Parentheses using Stack Have questions about Solution Review: Check Balanced Parentheses using Stack? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5754980359208960). Introduction to Graphs - Solution Review: Detect Cycle in Graph This review provides a detailed analysis of the different ways to solve the Detect a Cycle in a Graph challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5641906755207168). Introduction to Hashing - Solution Review: A List as a Subset of Another List This review provides a detailed analysis of the different ways to solve the A List as a Subset of Another List Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5644534738321408). Summary of Data Structures - Conclusion That's a wrap! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5744981138472960). Introduction to Hashing - Solution Review: Find Two Pairs Such That a+b = c+d This review provides a detailed analysis of the different ways to solve the Find Two Pairs Such That a+b = c+d Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5633049995771904). Trie - Solution Review: Find All Words Stored in Trie This review provides a detailed analysis of the different ways to solve the Find All Words Stored in Trie Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5743939608903680). Introduction to Heap - Solution Review: Find k smallest elements in a List Have questions about Solution Review: Find k smallest elements in a List? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5670377556541440). Introduction to Hashing - Solution Review: Find Symmetric Pairs in a List This review provides a detailed analysis of the different ways to solve the Find Symmetric Pairs in a List Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5681162219421696). Introduction to Hashing - Solution Review: A Sublist with a Sum of 0 This review provides a detailed analysis of the different ways to solve the A Sublist with a Sum of 0 Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5705944180719616). Introduction to Trees - Post-Order Traversal In this lesson, we will cover Post-Order Traversal in a Binary Search Tree and implement it in Python Introduction to Stack/Queues - Solution Review: Implementing Two Stacks using one Array This review provides a detailed analysis of the different ways to solve the Implementing Two Stacks using one Array challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5738522044530688). Introduction to Graphs - Types of Graphs This lesson showcases the two main categories of graphs. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5652096565116928). Introduction to Graphs - Solution Review: Implement Breadth First Search This review provides a detailed analysis of the different ways to solve the Implement Breadth First Search challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5660403031867392). Introduction to Complexity Measures - Common Complexity Scenarios This lesson summarizes our discussion of complexity measures and includes some commonly used examples and handy formulas to help you with your interview. Introduction to Lists - Solution Review: Find Second Maximum Value in a List This review provides a detailed analysis of the different ways to solve the Find Second Maximum Value in a List challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5132285263216640). Introduction to Complexity Measures - Solution Review: Big O of Nested Loop with Subtraction This review provides a detailed analysis of the time complexity of the Nested Loop with Subtraction problem! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5633722695024640). Introduction to Lists - Arrays In this lesson, we define arrays and how they are used in Python! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5745493850193920). Introduction to Stack/Queues - Solution Review: Evaluate Postfix Expression Using a Stack This review provides a detailed analysis of the different ways to solve the Evaluate Postfix Expression Using Stack challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5719074432614400). Introduction to Linked Lists - Solution Review: Detect Loop in a Linked List This review provides a detailed analysis of the different ways to solve the Detect a Loop in a Linked List challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/6287032317902848). Introduction to Trees - Implementing a Binary Search Tree in Python In this lesson, we'll implement a very basic Binary Search Tree in Python View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5755997729587200). Introduction to Complexity Measures - Solution Review: Big O of Nested Loop with Addition This review provides a detailed analysis of the time complexity of the Nested Loop with Addition problem! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5765183054020608). Introduction to Stack/Queues - Solution Review: Reversing First k Elements of Queue Have questions about Solution Review: Reversing First k Elements of Queue? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5700812231671808). Introduction to Linked Lists - Challenge 7: Find Middle Value of Linked List Here’s another interesting coding challenge to test your knowledge on linked lists. Introduction to Trees - AVL Insertion This lesson will cover the insertion operation in AVL trees, discussing all the four insertion cases. Introduction to Trees - What is a Red-Black Tree? This lesson is an introduction to Red-Black trees, their properties, and the total time they take to perform the operations of insertion, deletion, and searching. We will also do a small comparison between AVL and Red-Black Trees. Introduction to Trees - What is a Binary Tree? An introduction to binary trees and different types of binary trees Introduction to Complexity Measures - Example 1: Measuring Time Complexity In this lesson, we are going to learn how to compute the running time complexity of an algorithm that involves loops. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5691082318807040). Trie - Insertion in a Trie This lesson defines all the cases needed for inserting a word into a trie, along with the Pythonic implementation. Introduction to Trees - What is a 2-3 Tree? This lesson is an introduction to 2-3 trees, its properties along with an example, and the basic operations that this data structure offers. Introduction to Heap - Min Heap (Implementation) We’ll implement a min heap in this lesson! Introduction to Lists - Challenge 7: Find Second Maximum Value in a list Given an array of size n, can you find the second maximum element in the list? Implement your solution in Python and see if your output matches the correct output! Introduction to Lists - Solution Review: Rearrange Sorted List in Max/Min Form Have questions about Solution Review: Rearrange Sorted List in Max/Min Form? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5737480514961408). Introduction to Hashing - Building a Hash Table from Scratch This lesson is about how hash tables are implemented in Python. Introduction to Trees - AVL Deletion This lesson will cover the deletion operation in AVL trees, discussing all the four deletion cases. Trie - Challenge 1: Total Number of Words in a Trie For your first challenge regarding tries, you’ll be writing a very commonly used function which gives us the trie word count. Introduction to Trees - Red-Black Tree Deletion This lesson will cover the deletion function in Red-Black trees and will discuss all four deletion cases. Introduction to Trees - Trees Quiz: Test your understanding of Trees Here are the top ten most commonly asked interview questions about trees Introduction to Stack/Queues - Challenge 5: Sort Values in a Stack In this lesson, we will learn how to sort elements using a stack. Introduction to Trees - Solution Review: Find Ancestors of a given node in a Binary Tree This review provides a detailed analysis of the different ways to solve the Find Ancestors of a given node in a Binary Tree challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5742571661819904). Trie - Solution Review: Sort Elements of an Array Using Trie This review provides a detailed analysis of the different ways to solve the Array Sort Using Tries Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5707166098915328). Introduction to Graphs - Solution Review: Check if a Path Exists Between Two Vertices This review provides a detailed analysis of the different ways to solve the Check if a Path Exists Between Two Vertices Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5654456649646080). Introduction to Stack/Queues - Challenge 7: Next Greater Element Using in Stack Using a stack, can you implement a function to find the next greater element after any given element in a list? Introduction to Complexity Measures - Introduction to Asymptotic Analysis and Big O Asymptotic analysis is a way to classify the running time complexity of algorithms. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5642165526986752). Introduction to Lists - Challenge 8: Right Rotate List Given a list, can you rotate its elements by one index from right to left? Implement your solution in Python and see if your code runs successfully! Introduction to Lists - Solution Review: Rearrange Positive & Negative Values This review provides a detailed analysis of the different ways to solve the Rearrange Positive & Negative Values challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5672265731538944). Introduction to Linked Lists - Solution Review: Deletion by Value This review provides a detailed analysis of the different ways to solve the Deletion by Value challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5161132411060224). Introduction to Hashing - Trees vs Hash Table This lesson highlights the differences between trees and hash tables. Introduction to Linked Lists - Singly Linked Lists vs. Doubly Linked Lists Let's see how the two renditions of the linked list structure fare against each other. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5743314154291200). Introduction to Linked Lists - Challenge 8: Remove Duplicates from Linked List In this lesson, you must figure out the Pythonic solution for removing duplicates from a linked list. Introduction to Graphs - Graph Implementation This lesson will cover the implementation of a unidirectional graph via adjacency list in Python. We will also go through the time complexity of basic graph operations. Introduction to Trees - 2-3 Deletion (Case #1) This lesson will cover the deletion operation in 2-3 trees, discussing all the four scenarios based on the position of the element which needs to be deleted. Introduction to Graphs - Challenge 2: Implement Depth First Search After the BFS algorithm, we will now tackle the implementation for Depth First Search. Introduction to Trees - Solution: Find minimum value in Binary Search Tree This review provides a detailed analysis of the different ways to solve the Find minimum value in Binary Search Tree challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5666224323166208). Introduction to Linked Lists - Challenge 2: Search in a Singly Linked List This lesson explains how searching is done in a singly linked list. There is also a coding exercise to test your concepts. Introduction to Linked Lists - Solution Review: Remove Duplicates from a Linked List This review provides a detailed analysis of the different ways to solve the Remove Duplicates from a Linked List challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5071410544246784). Introduction to Lists - Challenge 6: First Non-Repeating Integer in a list Given a list, find the first integer which is unique in the list. Unique means the number does not repeat and appears only once in the whole list. Implement your solution in Python and see if it runs correctly! Introduction to Trees - Trees and their Basic Properties! In this chapter, we are going to study the basics of the tree data structure! Introduction to Linked Lists - Linked Lists Quiz: Test your understanding of Linked Lists Top ten most commonly asked interview questions about linked list will be covered in this lesson in the form of a quiz. Introduction to Trees - What makes a tree 'balanced'? In this chapter, we are going to study what makes a tree balanced. We are also going to look at a high-level description of the algorithm used to determine if a given tree is balanced. Introduction to Trees - What is a Binary Search Tree (BST)? This lesson will introduce Binary Search Trees and their properties Introduction to Graphs - Challenge 7: Check if Given Graph is Tree or not? In this lesson, we will learn the difference between a graph and a tree. You will use this knowledge for the challenge below. Introduction to Trees - In-Order Traversal In this lesson, we will cover In-Order Traversal and implement it in Python Introduction to Stack/Queues - Challenge 9: min() Function Using a Stack Using your knowledge, create an efficient min() function using a stack. Introduction to Graphs - Challenge 4: Find "Mother Vertex" in a Graph Given a graph, can you find a vertex which shares a common edge with all the other vertices? Introduction to Graphs - Solution Review: Count the Number of Edges in a Graph This review provides a detailed analysis of the different ways to solve the Count the Number of Edges in Graph Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5736232826961920). Introduction to Stack/Queues - Solution Review: Next Greater Element Using a Stack This review provides a detailed analysis of the different ways to solve the Next Greater Element Using a Stack challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5689765575786496). Introduction to Stack/Queues - Solution Review: Implement a Queue Using Stacks This review provides a detailed analysis of the different ways to solve the Implement a Queue Using Stacks challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5673461879930880). Introduction to Stack/Queues - Solution Review: min() Function Using a Stack This review provides a detailed analysis of the different ways to solve the min() Function Using a Stack challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5643517367943168). Introduction to Stack/Queues - Solution Review: Generate Binary Numbers from 1 to n using Queue Have questions about Solution Review: Generate Binary Numbers from 1 to n using Queue? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5717244776546304). Introduction to Trees - Binary Search Tree Insertion In this lesson, we’ll study the binary search tree insertion algorithm! Introduction to Lists - Challenge 2: Merge Two Sorted Lists Given two sorted lists, merge them into one list which should also be sorted. Implement the solution in Python and see if your code runs successfully! Introduction to Lists - Solution Review: Find Two Numbers that Add up to "n" This review provides a detailed analysis of the different ways to solve the find two numbers that add up to "n" challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5739975890960384). Introduction to Hashing - A Quick Overview of Hash Tables Let’s combine all the different operations discussed previously and test out the functionality of our complete hash table class. Introduction to Linked Lists - Challenge 1: Insertion at Tail Now, we’ll tackle the second insertion strategy in linked lists. However, you will be the one implementing it! Introduction to Complexity Measures - Challenge 4: Nested Loop with Multiplication (Advanced) This is a little-advanced exercise based on the Big O of an algorithm which involves nested loops and the loop variables increment with multiplication. Introduction to Lists - Challenge 4: List of Products of all Elements Given a list, return a list where each index stores the product of all numbers in the list except the number at the index itself. Introduction to Complexity Measures - Challenge 6: Nested Loop with Multiplication (Pro) A pro-level exercise based on the Big O of an algorithm which involves nested loops and the loop variables increment with multiplication and addition. Introduction to Hashing - Hashing Quiz: Test your understanding of Hashing Top ten most commonly asked interview questions about hashing will be covered in this lesson in the form of a quiz. Introduction to Hashing - Challenge 1: A List as a Subset of Another List Can you find whether a given list is a subset of another list by using a hash table? Introduction to Linked Lists - Doubly Linked Lists (DLL) After singly linked lists, we’ve come to the more evolved version of the linked list data structure: doubly linked lists. Introduction to Trees - Searching in a Binary Search Tree (Implementation) This lesson about Searching in Binary Search Tree and how to implement searching functionality in Python. Introduction to Hashing - What is a Hash Table? This lesson is a brief introduction to the hash table data structure and the basic principle behind implementing it. Introduction to Hashing - Challenge 3: Find Symmetric Pairs in a List Now we will implement a symmetry detection algorithm using hash tables. Introduction to Lists - Challenge 3: Find Two Numbers that Add up to "n" Given a list and a number “n”, find two numbers from the list that sum to “n”. Implement your solution in Python and see if your output matches with the correct output. Introduction to Linked Lists - Singly Linked Lists (SLL) This lesson is a brief introduction to the functionality and purpose of the popular data structure called linked lists. Introduction to Heap - Challenge 1: Convert Max-Heap to Min-Heap Given a Max-Heap convert it into a Min-Heap. A solution is placed in the “solution” section for your help, but we would suggest you solve it on your own first. Introduction to Complexity Measures - Challenge 1: Big O of Nested Loop with Addition Compute the Big O complexity of an algorithm which involves nested loops where the loop variables increase with addition. Introduction to Lists - Challenge 1: Remove Even Integers from List Given an array of size n, remove all even integers from it. Implement this solution in Python and see if it runs without an error. Introduction to Complexity Measures - Challenge 3: Big O of Nested Loop with Multiplication Compute Big O of an algorithm which involves nested loops and the loop variables increment with multiplication. Introduction to Linked Lists - Challenge 4: Find the Length of a Linked List Let’s write a function which can tell us the length of a linked list. Introduction to Complexity Measures - Complexity Quiz: Test your understanding of complexity The top ten most commonly asked interview questions about complexity measure will be covered in this lesson in form of a quiz. Introduction to Trees - Deletion in a Binary Search Tree (Implementation) We will now write the implementation of the deletion function which covers all the cases that we discussed previously Introduction to Linked Lists - Challenge 9: Union & Intersection of Linked Lists In this lesson, linked lists meet data set operations. Introduction to Trees - Challenge 4: Find the Height of a Binary Tree Given the root to a Binary Search Tree, write a function to find the height of the tree. A solution is placed in the “solution” section for your help, but we would suggest you to solve it on your own first. Introduction to Linked Lists - Challenge 10: Return the Nth node from End Returning the Nth node from the start of a linked list is easy. Can you return Nth node from the end of a list? Introduction to Stack/Queues - Stack (Implementation) In this lesson, we are going to look at how Stacks are implemented in Python and how the main Stack functions actually work Introduction to Hashing - Add/Remove & Search in Hash Table (Implementation) This lesson will cover the Pythonic Implementation for search, insertion, and deletion in hash tables. Introduction to Lists - Challenge 10: Rearrange Sorted List in Max/Min Form Arrange elements in such a way that the maximum element appears at first position, then minimum at second, then second maximum at third and second minimum at fourth and so on. Introduction to Graphs - Challenge 8: Find the Shortest Path Between Two Vertices We’ve dealt with several graph traversals. Now, we’ll find the shortest path traversal between to vertices. Introduction to Lists - Arrays Quiz: Test your understanding of Lists Arrays Top ten most commonly asked interview questions about lists will be covered in this lesson in form of a quiz. Introduction to Graphs - Graph Quiz: Test your understanding of Graphs Here are the ten most commonly asked interview questions about graphs. Introduction to Stack/Queues - Challenge 6: Evaluate Postfix Expression Using a Stack Let’s try to compute postfix mathematical expressions using stacks! Introduction to Graphs - Challenge 6: Check if a Path Exists Between Two Vertices Given a graph and two vertices, can you write a code to check if a path exists between the two vertices? Introduction to Graphs - Challenge 3: Detect Cycle in Graph Here’s another coding challenge on graphs. You’ll implement a cool function which detects loops! Introduction to Stack/Queues - Challenge 2: Implement Two Stacks using one Array Can you implement two stacks using a single array? A solution is placed in the “solution” section for your help, but we would suggest you to solve it on your own first. Introduction to Stack/Queues - Challenge 4: Implement a Queue Using Stacks We have seen the difference between stacks and queues, but is it possible to make one from the other? Let’s find out. Introduction to Heap - Max Heap: Introduction This lesson will give a brief introduction to Max-Heaps and how their elements are inserted or removed from Max-Heaps. Introduction to Stack/Queues - Challenge 3: Reversing First k Elements of Queue Can you reverse first “k” elements in a given queue? A solution is placed in the “solution” section for your help, but we would suggest you solve it on your own first. Introduction to Heap - Heap Quiz: Test your understanding of Heaps Here are the top ten most commonly asked interview questions on heaps! Introduction to Trees - Challenge 3: Find Ancestors of a given node in Binary Tree If you are given the root to a Binary Search Tree and a node value “k”, can you write a code to find the ancestor of that node? A solution is placed in the “solution” section for your help, but we would suggest you to solve it on your own first. Introduction to Heap - Challenge 3: Find k largest elements in the List If you are given a list and any number “k”, can you write a code to find first “k” largest elements using Max-Heap? Introduction to Hashing - Challenge 7: Word Formation Using a Hash Table We solved this problem using tries. Now, let’s try it out with hash tables. Introduction to Complexity Measures - Challenge 2: Big O of Nested Loop with Subtraction Compute Big O of an algorithm which involves nested loops and the loop variables decrement with subtraction. Introduction to Graphs - What is a Graph? This lesson is a brief introduction to the graph data structure, its types, and the standard terminologies used to describe it. Introduction to Lists - Challenge 5: Find Minimum Value in List Given a list of size ‘n,’ can you find the minimum value in the list? Implement your solution in Python and see if your output matches the expected output. Introduction to Graphs - Challenge 5: Count Number of Edges in a Graph In this lesson, we will figure out if it’s possible to count the total number of edges in a graph. Introduction to Stack/Queues - Stack/Queue Quiz: Test your understanding of Stack/Queue Top ten most commonly asked interview questions about stack and queue will be covered in this lesson in the form of a quiz. Introduction to Lists - Challenge 9: Rearrange Positive & Negative Values Given a list, can you re-arrange its elements in such a way that the negative elements appear at one side and positive elements appear in the other? Solve this problem in Python and see if your code runs correctly! Introduction to Complexity Measures - Other Common Asymptotic Notations and Why Big O Trumps Them This lesson introduces other members of the family of notations and why Big O is the most popular of them! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5699349795307520). Introduction to Complexity Measures - Solution Review: Big O of Nested Loop with Multiplication This review provides a detailed analysis of the different ways to solve the Big O of Nested Loop with Multiplication Quiz! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5705431468998656). Introduction to Complexity Measures - Solution Review: Nested Loop with Multiplication (Advanced) This review provides a detailed analysis of the different ways to solve the nested loop with multiplication problem View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5666536245166080). Trie - Solution Review: Total Number of Words in a Trie This review provides a detailed analysis of the different ways to solve the Total Number of Words in a Trie Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5678724825481216). Introduction to Complexity Measures - Useful Formulas In this lesson, we'll study some mathematical formulae that make calculating time complexity easier! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5675494473203712). Introduction to Linked Lists - Solution Review: Insertion at Tail This review provides a detailed analysis of the different ways to solve the Insertion at Tail challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5712679226310656). Introduction to Heap - Solution Review: Find k largest elements in the List Have questions about Solution Review: Find k largest elements in the List? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5736829290545152). Introduction to Hashing - Solution Review: Check if Lists are Disjoint This review provides a detailed analysis of the different ways to solve the Check if Lists are Disjoint Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5710161838604288). Introduction to Linked Lists - Challenge 6: Detect Loop in a Linked List Loops in linked lists can be dangerous. Now, you’ll create an algorithm to detect them. Introduction to Trees - Deletion in a Binary Search Tree In this lesson, we are going to learn how nodes are deleted in binary search trees. We will take a look at a few node deletion scenarios and what to do in each one. Introduction to Trees - Challenge 5: Find Nodes at "k" distance from the Root If you are given the root to a Binary Search Tree and a node value “k”, can you write a code to find the nodes at “k” distance from the root? A solution is placed in the “solution” section for your help, but we would suggest you to solve it on your own first. Introduction to Linked Lists - Challenge 5: Reverse a Linked List Can we implement a program which could reverse a linked list? Let’s find out. Introduction to Trees - More on Complete Binary Trees In this lesson, we are going to discuss what Complete Binary Trees are and how elements are inserted into them. Introduction to Lists - Solution Review: List of Products of All Elements This review provides a detailed analysis of the different ways to solve the list of products of all elements challenge! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5639868793225216). Introduction to Graphs - Solution Review: Find the Shortest Path Between Two Vertices This review provides a detailed analysis of the different ways to solve the Find the Shortest Path Between Two Vertices Challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5687682516647936). Trie - Challenge 2: Find All Words Stored in Trie If you are given a trie, can you return every word it contains? Introduction to Hashing - Solution Review: Word Formation Using a Hash Table This review provides a detailed analysis of the different ways to solve the Word Formation Using a Hash Table Challenge. Introduction to Linked Lists - Solution Review: Return the Nth Node for the End This review provides a detailed analysis of the different ways to solve the Detect a Loop in a Linked List challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/6197310451089408). Introduction to Trees - Red-Black Tree Insertion This lesson will cover the insertion operation in Red-Black trees, discussing all the four insertion cases. Introduction to Trees - Challenge 2: Find kth maximum value in Binary Search Tree Given the root to a Binary Search Tree and a number “k” write a function to find the kth maximum value in the tree. A solution is placed in the “solution” section for your help, but we would suggest you to solve it on your own first. Introduction to Complexity Measures - Solution Review: Nested Loop with Multiplication (Complex) This review provides a detailed analysis of the different ways to solve the nested loop with multiplication in an advanced problem! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5742058950098944). Introduction to Complexity Measures - Solution Review: Nested Loop with Multiplication (Pro) This review provides a detailed analysis of the different ways to solve the Nested Loop with Multiplication challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5650387168133120). Introduction to Trees - Challenge 1: Find minimum value in Binary Search Tree Given the root to a Binary Search Tree, write a function to find the minimum value in that tree. A solution is placed in the “solution” section for your help, but we would suggest you solve it on your own first. Introduction to Stack/Queues - Challenge 1: Generate Binary Numbers from 1 to n using a Queue Can you generate binary numbers from 1 to any given number “n”? Introduction to Complexity Measures - Challenge 5: Nested Loop with Multiplication (Complex) A more complex exercise based on the Big O of an algorithm which involves nested loops and the loop variables increment with multiplication. Introduction to Lists - Lists In this lesson, we define lists and how they are used in Python and how they are different from arrays! Introduction to Lists - Solution Review: Remove Even Integers from a List This review provides a detailed analysis of the different ways to solve the remove even integers from a list challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5698311486963712). Introduction to Lists - Solution Review: Merge Two Sorted Lists This review provides a detailed analysis of the different ways to solve the merge two sorted lists challenge View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5704393160654848). Introduction to Stack/Queues - Solution Review: Sort Values in Stack This review provides a detailed analysis of the different ways to solve the Sort Values in a Stack challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5653241173901312). Introduction to Linked Lists - Singly Linked List Deletion After insertion and search, we’ll be tackling the concept of deletion in a linked list. Introduction to Stack/Queues - What is a Queue? This lesson gives an introduction to the queue data structure, its various uses, and types. We will also go through the inner workings of a Queue by briefly discussing each of its functions. Introduction to Trees - Pre-Order Traversal In this lesson, we will cover the traversal strategy, ‘Pre-Order Traversal’ in a Binary Search Tree, and its implementation it in Python Introduction to Trees - Solution Review: Find Nodes at "k" distance from the Root This review provides a detailed analysis of the different ways to solve the Find Nodes at "k" distance from the Root challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5675342538735616). Introduction to Heap - Solution Review: Convert Max-Heap to Min-Heap Have questions about Solution Review: Convert Max-Heap to Min-Heap? Go for it! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/6332798952538112). Introduction to Hashing - Collisions in Hash Tables This lesson is about how collisions occur in hashing and the common strategies used in resolving these collisions. Introduction to Linked Lists - Solution Review: Find the Length of a Linked List This review provides a detailed analysis of the different ways to solve the Find the Length of a Linked List challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5685187140648960). Introduction to Linked Lists - Solution Review: Reverse a Linked List This review provides a detailed analysis of the different ways to solve the Reverse a Linked List challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5122237187227648). Introduction to Linked Lists - Solution Review: Find Middle Value of a Linked List This review provides a detailed analysis of the different ways to solve the Find the Middle Value in a Linked List challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5634360497668096). Introduction to Linked Lists - Solution Review: Union and Intersection of Linked Lists This review provides a detailed analysis of the different ways to solve the Union and Intersection of Linked Lists challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5634727314718720/5187211452481536). Introduction to Stack/Queues - Queue (Implementation) Lets look at the basic functionality and implementation of queues in Python! Introduction to Stack/Queues - Challenge 8: Check Balanced Parentheses Using Stack If you are given an expression, can you check if its parentheses are balanced? A solution is placed in the “solution” section for your help, but we would suggest you to solve it on your own first.
About the Data Structures in Python: An Interview Refresher (Coderust) category [Data Structures in Python: An Interview Refresher (Coderust)] (1)
Resizing in a Hash Table [Introduction to Complexity Measures - Useful Formulas] (1)
Purely adapted from another language [Data Structures in Python: An Interview Refresher (Coderust)] (2)
More Test Cases? [Data Structures in Python: An Interview Refresher (Coderust)] (2)
Simpler implementation? [Introduction to Linked Lists - Solution Review: Find Middle Value of a Linked List] (2)
Bug in the Linked List Quiz [Data Structures in Python: An Interview Refresher (Coderust)] (2)
Example 1 : Measuring Time Complexity [Introduction to Complexity Measures - Example 1: Measuring Time Complexity] (2)
Shorter variant [Introduction to Lists - Solution Review: Rearrange Sorted List in Max/Min Form] (3)
Thoughts about 3rd solution? [Introduction to Lists - Solution Review: List of Products of All Elements] (2)
Second maximum task may need clarification [Introduction to Lists - Solution Review: Find Second Maximum Value in a List] (3)
Error in the 3rd formula? [Introduction to Complexity Measures - Useful Formulas] (2)
Test Comparing Value Incorrectly [Introduction to Trees - Challenge 3: Find Ancestors of a given node in Binary Tree] (3)
Problem with Challenge 5 [Introduction to Complexity Measures - Solution Review: Nested Loop with Multiplication (Complex)] (2)
Formula to find possible edges in directed and undirected graph [Data Structures in Python: An Interview Refresher (Coderust)] (2)
Bug in the testing? [Introduction to Trees - Challenge 3: Find Ancestors of a given node in Binary Tree] (2)
there can be multiple mother vertices. [Introduction to Graphs - Challenge 4: Find "Mother Vertex" in a Graph] (2)