# Data Structures in Java: An Interview Refresher (Coderust)

Trees - Insertion in Binary Search Trees In this lesson we will discuss the steps performed while inserting an element into the Binary Search Tree. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5668555215339520). Trees - Post-Order Traversal in Binary Search Tree In this lesson, we will cover the third and last traversal strategy for a Binary Search Tree—Post-Order Traversal—and implement it in code by using an example. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5719106980413440). 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. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5740532424769536). Trees - 2-3 Deletion (Case #1) This lesson will cover the deletion operation in 2-3 Trees, discussing all four of the scenarios based on the position of the element that needs to be deleted. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5754916270243840). Complexity Measures - Example 2: Time Complexity of an Algorithm With Nested Loops In this lesson, we will learn how to compute the time complexity of an algorithm that involves nested for loops. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/m2MloJQz0wA). Trees - Solution Review: Find the Minimum Value in a Binary Search Tree This review provides a detailed analysis of the different ways to solve the Find minimum value in Binary Search Tree challenge Trees - Solution Review: Find Nodes at "k" Distance from the Root This review provides a detailed analysis to solve the Find Nodes at “k” distance from the Root challenge Trie (Advanced Trees) - Solution Review: Word Formation from a Given Dictionary using a Trie This review provides a detailed analysis to solve the Word Formation from a Given Dictionary Using a Trie Challenge. Hash Tables - Solution Review: Trace the complete path of a journey This review provides a detailed analysis to solve the Trace the Complete Path of a Journey Challenge. Trees - Types of Trees In this chapter, we are going to discuss N-ary and Balanced Trees. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5629608451899392). Trie (Advanced Trees) - Solution Review: Sort the Elements of an Array using a Trie. This review provides a detailed analysis to solve the Sort the Elements of an Array using a Trie Challenge. Summary of Data Structures - Conclusion That's a wrap! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5694080407306240). Trees - What is a Binary Tree? This lesson is about Binary Trees and their different variations. We will also look at some basic properties of a Perfect Binary Tree and a Full Binary Tree, as they are the most commonly used types of Binary trees. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5707811216424960). Hash Tables - Solution Review: Find symmetric pairs in an Array This review provides a detailed analysis to solve the Find Symmetric Pairs in an Array Challenge. Linked Lists - Linked List with a Tail In this lesson, we will study another variation of linked lists called "Linked List with a Tail". We will also learn the benifits of using a tail pointer in both SLL and DLL. An implementation of DLL with a Tail will also be covered. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/4549389907394560). Linked Lists - Insertion in Singly Linked List (Insert After) Now that we've covered "insert at head" and "insert at end", we will discuss "insert after" and implement it in Java. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/RM1wz6AzLLz). Trees - Tree Interview Questions Top ten most commonly asked interview questions about tree will be covered in this lesson in form of a quiz. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5670332794929152). Linked Lists - Solution Review: Find the Length of a Linked List This review provides a detailed analysis of how to solve the Find the Length of a Linked List challenge. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/m2Em0YEnjkr). Heaps - Heap Interview Questions Top ten most commonly asked interview questions about the Heap will be covered in this lesson in the form of a quiz. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5736784528932864). Heaps - Max Heap: Introduction This lesson will give a brief introduction about Max Heap and how elements are inserted or removed from Max-Heap. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5717200014934016). Introduction to Complexity Measures - Example 3: Measuring Time Complexity Compute the time complexity of a given algorithm with a loop incrementing through multiplication and see how polynomial functions are transformed into Big(O). Complexity Measures - An Overview of Complexities This lesson summarizes our discussion of complexity measures and includes some commonly used examples and handy formulas to help you with your interview. Linked Lists - Singly Linked List Deletion (Implementation) This lesson is about deleting an element from the linked list along with its implementation in Java. Hash Tables - Challenge 8: Remove Duplicate from a Linked List using Hashing Given a linked list, remove duplicates from it and implement the solution using Hashing. Solve this exercise and see if your output matches the expected output. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5581669945835520). Trie (Advanced Trees) - Trie Interview Questions Top ten most commonly asked interview questions about trie will be covered in this lesson in form of a quiz. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5156542835851264). Linked Lists - Linked List with Tail In this lesson we will learn about Linked list with Tail, also the implementation of DLL with tail and how to implement its functions. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5568566990471168). Trees - What is a Binary Search Tree (BST)? This lesson will briefly discuss Binary Search Trees and what properties they hold. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5766420340146176). Linked Lists - Solution Review: Insertion in a Singly Linked List(insert at End) This review provides a way to solve the Insertion at the End challenge. Trees - More on Complete Binary Trees In this lesson, we are going to discuss what mechanism of insertion of elements into Complete Binary Trees. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5750116644290560). Trees - Deletion in Binary Search Trees In this lesson, we are going to learn how deletion operations are performed in Binary Search Trees. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5639383797465088). Trie (Advanced Trees) - The Structure of a Trie This lesson covers the structure of a Trie class, including TrieNode and how all of this information is programmed in Java. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5688895442255872). Linked Lists - Solution Review: Deletion in a Singly Linked List This review provides a detailed analysis of how to solve the Deletion in a Singly Linked challenge. Linked Lists - Solution Review: Deletion in Singly Linked List This review provides a detailed analysis of how to solve the Deletion in the Singly linked list challenge. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/gkpygwMvLq9). Graphs - Complexities of Graph Operations Let's discuss the performance of the two graph representation approaches. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/NEYvz0nqZl6). Complexity Measures - Solution Review: Big O of a Nested Loop with Addition This review provides a detailed analysis of the time complexity of the Nested Loop with Addition problem! Trees - Search in Binary Search Trees (Implementation) This lesson is about Searching in a Binary Search Tree, and how to implement searching functionality in Java. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5748078682308608). 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. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/NE8AoLj5ogp). Complexity Measures - Challenge 3: Big O of Nested Loop with Multiplication Compute the Big O of an algorithm that involves nested loops, and increments the loop variables through multiplication. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/JYPElD65lKD). Graphs - Solution Review: Implement Depth First Search This review provides a detailed analysis to solve the Implement Depth First Search challenge. Graphs - Solution Review: Cycle Detection in the Graph This review provides a detailed analysis to solve the Detect a Cycle in a Graph challenge. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/R8NKkXQ7pDV). Heaps - Min Heap: An Introduction This lesson will give a brief introduction about Min Heap, and how elements are inserted or removed from them. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5673442888122368). Linked Lists - Solution Review: Find the Middle Value of a Linked List This review provides a detailed analysis of how to solve the Find the Middle Value in a Linked List challenge. 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 challenge. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/YQ7XDzQ8RAK). Complexity Measures - Challenge 7: Nested Loop with Multiplication (Pro) A pro-level exercise based on Big(O) of an algorithm involving nested loops and the loop variables increment with multiplication and addition. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/N7VBkEJYypK). Arrays - Solution Review: Re-arrange Sorted Array in Max/Min Form This review provides a detailed analysis to solve the Re-arrange Sorted Array in Max/Min Form challenge. Heaps - Heap Representation in Arrays The lesson elaborates how to Use Arrays for the Implementation of Heaps. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5754587369701376). Trees - Pre-Order Traversal in Binary Search Trees In this lesson, we will cover the first traversal strategy in a Binary Search Tree-- Pre-Order Traversal--and implement it in code by using an example. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5086157650001920). Trees - In-Order Traversal in Binary Search Trees In this lesson, we will cover the second traversal strategy for a Binary Search Tree—In-Order Traversal--and implement it in code by using an example. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5653273721700352). 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/courses/data-structures-in-java-an-interview-refresher/RLDLkV7nO4L). 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/courses/data-structures-in-java-an-interview-refresher/7nQ31j9M6zA). Hash Tables - Solution Review: Remove Duplicate from Linked List using Hashing This review provides a detailed analysis to solve the Remove Duplicates from a Linked List challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5001213487611904). Heaps - Max Heap (Implementation) How is Max-Heap implemented in Java? Let's find out in this lesson. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5161164958859264). Trie (Advanced Trees) - What is a Trie? This lesson gives a brief introduction to Trie, its properties, and common applications. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5719492789272576). Hash Tables - Collisions in Hash Tables This lesson is about how collisions occur, and the common strategies like Linear Probing, Chaining, and Re-sizing array used in resolving them. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5686364297232384). Trees - Insertion in BST (Complete Implementation) This chapter will cover the implementation of Binary Search Tree insertion in Java by using the iterative and recursive approaches. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5681626948304896). Heaps - Solution Review: Find the k Smallest Elements in an Array This review provides a detailed analysis to solve the Find the k Smallest Elements in an Array Challenge. Linked Lists - Challenge 3: Deletion in Singly Linked List(Delete by Value) Based on how we handled the deletion at head strategy, let's write the function for deletion by value. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/N0ZwvQR25mD). Linked Lists - Linked Lists vs. Arrays Let's put the two data structures against each other to find out which is more efficient. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/qAnopAn2J03). Stack/Queues - Solution Review: Generate Binary Numbers from 1 to n using Queue This review provides a detailed analysis to solve the Generate Binary Numbers from 1 to n using Queue challenge Complexity Measures - Challenge 4: Nested Loop with Multiplication (Basic) A basic exercise based on the Big(O) of an algorithm that involves nested loops and the loop variables increment with multiplication. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/3jyOpEnD71Q). Hash Tables - Add/Remove & Search in a Hash Table (Implementation) This lesson will cover how to add, remove, and search an element by its key in the Hash Table. We will be using the previously built Hash Table to see if it runs on the given driver. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5640425327034368). Trees - Overview of Trees This lesson is a quick overview of trees, their types, and some important formulas to compute the height and number of nodes in a tree. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5643453278978048). Arrays - Solution Review: Array of Products of All Elements Except Itself This review provides a detailed analysis of how to solve the problem, “Array of Products of All Elements Except Itself.” Hash Tables - What is a Hash Table? A brief introduction on Hash Tables and the use of the Hash function, along with some strategies to build it. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5178035590397952). Trees - Solution Review: Find the Height of a Binary Tree This review provides a detailed analysis to solve the Find the Height of a Binary Tree challenge Arrays - Solution Review: Merge Two Sorted Arrays This review provides a detailed analysis to solve the merge two sorted arrays challenge. Graphs - What is a Bipartite Graph? This lesson is about Bipartite Graphs and their key features. We will also take a look at Complete Bipartite graphs along with some examples. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/YQVGRZo23rn). Heaps - Why Use Heaps? The lesson highlights the significant applications and reasons for picking Heaps Data Structure while programming. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5644979804307456). Trees - What is a 2-3 Tree? This lesson is an introduction to 2-3 trees and their properties, along with an example of the basic operations that this data structure offers. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5724114912280576). Arrays - Array Interview Questions Top ten most commonly asked interview questions about array will be covered in this lesson in form of a quiz. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/B8RzjwGl7zN). Graphs - Graph Interview Questions Top ten most commonly asked interview questions about graph will be covered in this lesson in form of a quiz. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5654183717896192). Trie (Advanced Trees) - Search in a Trie This lesson defines all the cases we need to consider when searching for a word in a Trie. We will also look at the implementation of this algorithm in Java. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5727644637200384). Trie (Advanced Trees) - Solution Review: Find All of the Words in a Trie This review provides a detailed analysis to solve the Find All of the Words in Trie Challenge. Trees - AVL Insertion This lesson will cover the insertion operation in AVL trees, discussing all four insertion cases. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5733864488042496). Hash Tables - Building a Hash Table from Scratch This lesson is about how Hash Tables are implemented in Java and how we build a Hash function. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5758485388066816). Hash Tables - Challenge 7: First Non-Repeating Integer in an Array Given an array, find the first integer which is unique in the array using hashing technique. Implement your solution in Java and see if it runs correctly! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5740542245732352). Hash Tables - Solution Review: Check if the given arrays are disjoint This review provides a detailed analysis to solve the Check if the given Arrays are Disjoint Challenge. Complexity Measures - Challenge 1: Big (O) of Nested Loop with Addition Compute the Big O complexity of an algorithm that involves nested loops where the loop variables increase with addition. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/m2MMRvzkxDO). Hash Tables - HashMap vs HashSet This lesson will discuss the difference between HashMap and HashSet and look at some of their key features. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5722551007313920). Trie (Advanced Trees) - Deletion in a Trie This lesson defines all the cases needed for deleting a word in Trie, along with implementing this functionality in Java. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5698645018017792). Complexity Measures - Challenge 6: Nested Loop with Multiplication (Advanced) An advanced exercise based on the Big O of an algorithm. Like before, it involves nested loops in which the loop variables increment through multiplication and addition. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/gxQyDzZnQWZ). Linked Lists - Insertion in a Singly Linked List This explains the algorithm for insertion in the Singly Linked List in Java. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/7n9V6y6KzB8). Hash Tables - Trie vs Hash Table This lesson highlights the differences between a Trie and a Hash Table, including their common applications. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5643059551272960). Arrays - Solution Review: Re-arrange Positive & Negative Values This review provides a detailed analysis of the different ways to solve the Rearrange Positive & Negative Values challenge. Hash Tables - Hashing Interview Questions Top ten most commonly asked interview questions about hashing will be covered in this lesson in form of a quiz. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5704254446632960). Hash Tables - Solution Review: Union and Intersection of Lists using Hashing This review provides a detailed analysis of how to solve the Union and Intersection of Linked Lists using Hashing challenge. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/6632913791614976). Hash Tables - Challenge 9: Union and Intersection of Lists using Hashing Given two lists, find the Union & Intersection of their elements using Hashing. Solve this exercise and see if your output matches the expected output. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5031862374236160). Trees - Deletion in Binary Search Trees (Implementation) We will cover the implementation of deletion, including all the cases that we discussed previously: Node as a Leaf, Parent Node with one child, and Parent Node with two children. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5708977300045824). Trees - What is a Red-Black Tree? This lesson is an introduction to Red-Black trees, their properties, and the total time it takes to perform the operations of insertion, deletion, and searching. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5649107603423232). Arrays - Two Dimensional Arrays This lesson will briefly explain what Two Dimensional Arrays are and how they are indexed. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/B8Q9XGrlLmJ). Graphs - Solution Review: Check if a Path exists between two vertices This review provides a detailed analysis to solve the Check if a Path Exists Between Two Vertices Challenge. Complexity Measures - Other Common Asymptotic Notations and Why Big O Trumps Them This lesson covers the various asymptotic notations for algorithms and why computer scientists prefer Big O instead of other notations. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/7nV9EDoDjMw). Stack/Queues - Solution Review: Create Stack where min() gives minimum in O(1) This review provides a detailed analysis of the different ways to solve the min() Function Using a Stack challenge. Arrays - Solution Review: Right Rotate the Array by One Index This review provides a detailed analysis to solve the Right Rotate the Array by One Index challenge. Trie (Advanced Trees) - Insertion in a Trie This lesson defines all the cases needed for inserting a word in Trie, along with showing how to implement this functionality in Java. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5662197925543936). Trees - Red-Black Tree Insertion This lesson will cover the insertion operation in Red-Black trees, discussing all the four insertion cases. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5693526155198464). Stack/Queues - Solution Review: Next Greater Element using Stack This review provides a detailed analysis to solve the Next Greater Element Using a Stack challenge. Stack/Queues - What is a Queue? This lesson is about Queues, their different uses, and their types. We will also go through the working of a Queue by briefly discussing each of its functions. Trees - What is a Tree? In this chapter, we are going to give a basic introduction of Trees and discuss different components/terminologies used in Trees. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5729079894474752). Graphs - Representation of Graphs The lesson elaborates on how a graph can be represented using the Adjacency List and Adjacency Matrix. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/RMP2RPWZZZq). Trees - Red-Black Tree Deletion This lesson will cover the deletion operation in Red-Black Trees, discussing all four of the deletion cases. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5154250061512704). Linked Lists - Solution Review: Search in a Singly Linked List This review provides a detailed analysis to solve the Search in a Singly Linked List challenge. Complexity Measures - Solution Review: Big O of a Nested Loop with Subtraction This review provides a detailed analysis of the different ways to solve the Nested Loop with Subtraction challenge. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/YQlRk4WjPnp). Complexity Measures - Useful Formulae In this lesson, we'll study some mathematical formulae that would make calculating time complexity easier! View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/RMO9lVNjjyR). Linked Lists - What is the Singly Linked List (SLL)? In this lesson, we will be introduced to the Singly Linked List and its structure, along with some basic operations that this data structure offers. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/xV60X8G2rqq). Linked Lists - Solution Review: Remove Duplicate from a Linked List This review provides a detailed analysis to solve the Remove Duplicates from a Linked List challenge. Stack/Queues - Solution Review: Solve a Celebrity Problem using a Stack This review provides a detailed analysis to solve the Celebrity Problem using a Stack challenge. Complexity Measures - Introduction to Asymptotic Analysis and Big O In this lesson, we will learn about asymptotic notation, an important tool applied to the analysis of algorithms. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/3jjG7y1LAkO). Stack/Queues - Stack (Implementation) How is Stack implemented in Java? What are some of the main methods that each stack have? That is what we are going to cover in this lesson. Hash Tables - Solution Review: First Non-Repeating Integer in an Array This review provides a detailed analysis of the different ways to solve the First Non-Repeating Integer in an array challenge! View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/6370974725308416). Linked Lists - Linked list Interview Questions The top ten most commonly asked interview questions about linked-lists will be covered in this quiz. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/JYzXBmLzR02). Stack/Queues - Stack/Queue Interview Questions Top ten most commonly asked interview questions about stack and queue will be covered in this lesson in the form of a quiz. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/7n9YVj2Mp2B). Heaps - What is a Heap A brief introduction to Heaps and their uses. We will also look at Heap Property and how a Heap is represented on an array. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/6212057556844544). Trees - What Makes a Tree Balanced? In this chapter, we are going to discuss what balanced trees are, and how to determine if a tree is balanced or not? View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5657310990958592). Linked Lists - Solution Review: Detect Loop in a Linked List This review provides a detailed analysis of how to solve the Detect a Loop in a Linked List challenge. Linked Lists - What is a Doubly Linked List (DLL)? This lesson briefly discusses the Doubly Linked List and how it is different from a Singly Linked List. We will also look at its implementation in Java. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/JPWmDJVL3WJ). Complexity Measures - Challenge 2: Big (O) of Nested Loop with Subtraction Compute Big(O) of an algorithm that involves nested loops and the loop variables decrement. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/qVAko0wprA2). 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 the Ancestors of a given node in a Binary Tree challenge Stack/Queues - What is a Stack? In this lesson, we will be introduced to the stack data structure, its uses, and its functionality. 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 to help you, but we would suggest you try to solve it on your own first View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/qVZZkJE4Vkp). Hash Tables - Hash Functions The lesson elaborates on Hash functions and how they work. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5746920853078016). Heaps - Solution Review: Convert a Max-Heap to a Min-Heap This review provides a detailed analysis to solve the Convert a Max-Heap to a Min-Heap Challenge. Trees - 2-3-4 Trees This lesson is a brief introduction to 2-3-4 Trees. We will discuss their key features and take a look at some examples. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5718475083350016). Trees - What is an AVL Tree? This lesson is a brief introduction to AVL trees, why they are used, and how efficient they are. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5740985543819264). Trees - AVL Deletion This lesson will cover the deletion operation in AVL trees, discussing all the four deletion cases. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5187166690869248). Hash Tables - Solution Review: Find whether an array is a subset of another array This review provides a detailed analysis to solve the An Array as a Subset of Another Array Challenge. Trees - Solution Review: Find kth Maximum Value in a Binary Search Tree This review provides a detailed analysis to solve the Find kth maximum value in Binary Search Tree challenge Hash Tables - Complete Implementation of Hash Tables Combine all the parts discussed previously into one executable code to see if it runs on the given driver. If it does, this means that our Hash Table works perfectly. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5656782173110272). Hash Tables - Solution Review: Find two pairs in an Array such that a+b = c+d This review provides a detailed analysis to solve the Find Two Pairs Such That a+b = c+d Challenge. Graphs - Solution Review: Count the number of Edges in a Graph This review provides a detailed analysis to solve the Count the Number of Edges in Graph Challenge. Trees - Skewed Binary Tree In this lesson, we will discuss another type of Binary Tree-–a Skewed Binary Tree. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/6231505168760832). Hash Tables - Solution Review: Find if a subarray with a sum equal to 0 exists. This review provides a detailed analysis to solve the A Subarray with a sum equal to 0 Challenge. Heaps - Min Heap (Implementation) How is a Min Heap implemented in Java? Let's find out in this lesson. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5738554592329728). Graphs - Solution Review: Find the Shortest Path between Two Vertices This review provides a detailed analysis to solve the Find the Shortest Path Between Two Vertices Challenge. Arrays - What is an Array? This lesson briefly defines arrays, and it's types. We will also discuss how arrays are stored in memory. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/gx2vRWpY693). Complexity Measures - Solution Review: Nested Loop with Multiplication (Intermediate) Here's a solution review for the exercise in the last lesson. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/RLj5pgVjvgV). 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. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5689701486821376). Heaps - Solution Review: Find the k Largest Elements in an Array This review provides a detailed analysis to solve the Find the k Largest Elements in an Array Challenge. Arrays - Solution Review: Remove Even Integers from an Array This review provides a detailed analysis to solve the “Remove Even Integers from an Array” challenge. Graphs - Graph Implementation This lesson will cover the implementation of a directed Graph via Adjacency List. We will also go through the time complexity of basic graph operations. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/NE8lYwzMKjN). Arrays - 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. Stack/Queues - Solution Review: Sort the Values in a Stack This review provides a detailed analysis of the different ways to solve the Sort Values in a Stack challenge. Trie (Advanced Trees) - Solution Review: Total Number of Words in a Trie This review provides a detailed analysis to solve the Total Number of Words in a Trie Challenge. Complexity Measures - Comparing Algorithms In this lesson, we are going to learn how two or more algorithms may be compared. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/xVVyKOr31Qn). Stack/Queues - Solution Review: Reversing the First k Elements of a Queue This review provides a detailed analysis to solve the Reversing First k Elements of Queue challenge Arrays - Solution Review: Find Minimum Value in an Array This review provides a detailed analysis to solve the find minimum value in an array challenge. Linked Lists - Solution Review: Union & Intersection of Lists This review provides a detailed analysis of how to solve the Union and Intersection of Linked Lists challenge. Stack/Queues - Solution Review: Evaluate Postfix Expressions using Stacks This review provides a detailed analysis to solve the Evaluate Postfix Expression Using Stack challenge. Graphs - Graph Traversal Algorithms This lesson will cover the key points to traverse a graph, and will also briefly describe two famous graph algorithms— Breadth First Search and Depth First Search. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/gx8NKY3J326). Graphs - Challenge 7: Check if the Given Graph is a Tree? Given a graph, can you write a code to check if it is a tree or not? A solution is placed in the "solution" section to help you, but we would suggest trying to solve it on your own first. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/qVDXOZ0pnzD). Complexity Measures - Solution Review: Nested Loop with Multiplication (Basic) This review provides a detailed analysis of how to solve the nested loop with a multiplication problem. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/3jEzr1VWy7p). Stack/Queues - Solution Review: Check for Balanced Parentheses using a Stack This review provides a detailed analysis to solve the Check Balanced Parentheses using Stack challenge Graphs - What is a Graph? The lesson explains multiple types and terminologies used in graphs (from basic to complex). View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/gxQ283421q9). Linked Lists - Solution Review: Return the Nth node from End This review provides a detailed analysis of how to solve the Return the Nth Node from the End in a Linked List challenge. Complexity Measures - Common Complexity Scenarios This lesson summarizes our discussion of complexity measures and includes some commonly used examples and handy formulae to help you with your interview. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/7nDJ65mBW2A). Complexity Measures - Challenge 5: Nested Loop with Multiplication (Intermediate) Here's an intermediate level exercise to determine the Big(O) time complexity of an algorithm that involves nested loops and the loop variables increment with multiplication. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/RMwpJkR4qOK). Complexity Measures - Complexity Interview Questions The top ten most commonly asked interview questions about Complexity Measurement will be covered in this lesson in the form of a quiz. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/gxQxZy2PrDY). Linked Lists - Solution Review: Reverse a Linked List This review provides a detailed analysis of how to solve the Reverse a Linked List challenge. Complexity Measures - Example 1: Measuring Time Complexity of a Single Loop Algorithm In this lesson, we are going to learn how to compute the time complexity of an algorithm that involves a for loop. View the lesson [here](https://www.educative.io/courses/data-structures-in-java-an-interview-refresher/7nn1ggVyL7O). Stack/Queues - Queue (Implementation) How is Queue implemented in Java? What are some of the main methods that each Queue have? That is what we are going to cover in this lesson. Graphs - Solution Review: Find "Mother Vertex" in a Graph This review provides a detailed analysis to solve the Find “Mother Vertex” in a Graph challenge. Stack/Queues - Solution Review: Implement Queue using Stack This review provides a detailed analysis to solve the Implement a Queue Using Stacks challenge. Graphs - Solution Review: Implement Breadth First Search This review provides a detailed analysis to solve the Implement Breadth First Search challenge. Arrays - Solution Review: First Non-Repeating Integer in an Array This review provides a detailed analysis to solve the First Non-Repeating Integer in an array challenge! Arrays - Solution Review: Find Second Maximum Value in an Array This review provides a detailed analysis of the different ways to solve the Find Second Maximum Value in an array challenge Summary of Data Structures - Overview of Linear & Non-Linear Data Structures In this lesson, we will have a review of the time complexities for all the data structures we have studied. We will also categorize them into linear and non-linear data structures. View the lesson [here](https://www.educative.io/collection/page/5642554087309312/5724822843686912/5691678782390272).

About the Data Structures in Java: An Interview Refresher (Coderust) category
[Data Structures in Java: An Interview Refresher (Coderust)]
(1)

Binary Tree search vs Binary Search Tree search time complexity
[Summary of Data Structures - Overview of Linear & Non-Linear Data Structures]
(2)

Solution with TreeMap with similar to the solution with HashMap
[Hash Tables - Solution Review: First Non-Repeating Integer in an Array]
(3)

No option to see the answer without answering all the right questions
[Trees - Tree Interview Questions]
(3)

Code Gives error: duplicate class: Trie at main.java:3
[Trie (Advanced Trees) - Deletion in a Trie]
(3)

Why log(n) + n = O(n)?
[Complexity Measures - Solution Review: Big O of Nested Loop with Multiplication]
(2)

Question on Linked List 'Insertion in a Singly Linked List' program
[Linked Lists - Insertion in a Singly Linked List]
(2)

Probably a better solution
[Hash Tables - Solution Review: Trace the complete path of a journey]
(2)

How to store edge value?
[Graphs - Solution Review: Find the Shortest Path between Two Vertices]
(2)

Can improve the time complexity of this solution to O(V)
[Graphs - Solution Review: Count the number of Edges in a Graph]
(2)

Difference of the sequence of 'visited' between BFS and DFS
[Graphs - Solution Review: Implement Depth First Search]
(2)

It is great challenge, I got it
[Linked Lists - Solution Review: Remove Duplicate from a Linked List]
(2)

Log2(n)*(4n-4) transformation for nested sum++
[Complexity Measures - Solution Review: Big O of Nested Loop with Multiplication]
(5)

Why is the correct answer marked O(nlog(n)) instead of O(nlog3(n))?
[Complexity Measures - Challenge 5: Nested Loop with Multiplication (Intermediate)]
(2)

The total number of non-leaf nodes in a complete binary tree of height “h”
[Trees - More on Complete Binary Trees]
(2)

Difference between the output and the graphical example
[Graphs - Solution Review: Implement Depth First Search]
(2)

Question regarding the algorithm described in the slides
[Stack/Queues - Solution Review: Solve a Celebrity Problem using a Stack]
(2)

Run times of Comparison statement - Simple for loop
[Complexity Measures - Common Complexity Scenarios]
(6)