Learn Data Structures & Algorithms for Interviews - PART 1

Master a recursive algorithm to sum array elements by solving smaller subproblems, establishing a base case, and then combining results. Use last index plus the rest to build the sum.

Learn how to implement a Java recursive function to sum digits in an array, using a base case and recursive calls, while handling array length and returning the total.

Learn to generate the factorial series for any number using recursion, with a base case of one and n multiplied by (n-1) factorial.

Learn factorial recursion in Java by implementing a base case and recursive call, then build the algorithm and pseudocode for interview prep, with a preview of Fibonacci.

Develop recursion in java by implementing a fibonacci method with base cases 0 and 1 and fib(n) = fib(n-1) + fib(n-2), then print fib(8) to show the result.

Learn how a linker list uses connected nodes with data and a next reference, with head and tail pointers, to support insertions and reversals.

Learn how to add a node at the end of a linked list by linking it to the tail, updating the tail pointer, and handling empty lists.

Define a Java linked list by creating a node inner class with value and next, add at end using head and tail, and use a constructor to set node values.

Implement a Java print linked list method by initializing current from head, iterating while current is not null, printing current.val, and moving to next, using head, tail, and current pointers.

Learn to insert a new node into a linked list at a given index in Java, by locating the previous node with a current pointer and a temp variable.

Learn how to delete a node at a specified index in a linked list by locating the previous node, updating the pointers, and disconnecting the target node.

Reverse a linked list using three pointers—current, previous, and next—without changing head or tail, by iteratively flipping links to point backward until null.

Learn to reverse a linked list in Java using three pointers: current, next, and previous. Traverse and swap links, then print the reversed list from the correct starting node.

Learn the stack data structure, a last-in-first-out linear structure, and its core operations—push, pop, peak—plus empty/full checks and real-world uses like undo.

Learn to implement and manipulate a stack in Java with java.util.Stack, using push, pop, peek, contains, and inserting elements at a specific index.

Learn how to insert an item into a stack at a given index using a temporary stack, size-based looping, and push and pop transfers.

Push opening brackets onto a stack while iterating the string and pop to match closing ones, determining balance with the Java isBalanced method for square brackets and curly braces.

Learn how to implement a queue using a Java array, including NQ and DQ operations, with constructor initialization and in-place element shifting.

Explore time complexity with a focus on constant time O(1). Learn to compare algorithms using worst case, and see examples like checking evenness, retrieving first element, and map lookups.

Discover time complexity patterns for common data-structure operations, from constant time deletions to linear-time traversals. Learn how binary search yields log time and where square and factorial cases occur.

Explore bubble sort and other sorting techniques, analyze time complexities, and learn how outer and inner loops bubble the largest number to the end.

implement bubble sort in java with nested loops, swapping adjacent elements to sort an array, and analyze time complexity as n squared in both best and worst cases.

Demonstrates Java implementation of selection sort with an outer loop tracking the minimal element and inner loop swapping, and explains its n squared time complexity and comparisons to other sorts.

Create a Java program that divides an array into left and right halves recursively, uses a base condition for single-element arrays, and prepares a merge step to combine sorted halves.

Demonstrate non-recursive and recursive binary search in Java, using left, right, middle, base conditions, updating pointers to find a target and show indices with log time complexity for interviews.

Explore jump search for interview questions, using a sqrt(n) block strategy to locate a target like 17 in a sorted array, illustrating block-based elimination and linear search within a block.

Use sqrt(n) time search by partitioning the array into blocks of size sqrt(length) and scanning the target block with two pointers in Java.

Understand how binary trees organize data nonlinearly to boost access speed, and why binary search trees maintain sorted order with nodes holding left and right references.

implement a binary search tree from the given list, with smaller items on the left and larger items on the right of the root, then compare to the solution diagram.

Implement a Java height algorithm for a binary search tree using a recursive method with a null base case and a wrapper getHeight for testing, highlighting height changes with insertions.

Explore how a hash map stores key-value pairs in Java, uses put and get for insertion and retrieval, and iterates entries with entry sets.

Explore hash map operations, learn how putAll merges maps, retrieve keys with keySet, and verify existence with containsKey and containsValue, including handling duplicates and overrides.

Learn how a hash map stores key-value pairs in an internal array of buckets, using a hash function and modulo to locate the correct bucket and support put and get.

Learn how hash code converts strings to numerical values via ascii and maps them to hash map buckets using a hash function, and how collisions occur for objects.

Learn how hash maps compute hash codes, place key-value pairs in buckets, handle collisions with linked lists, support null keys and values, and O(1) retrieval or sorting via tree map.