Learn Data Structures & Algorithms for Interviews - PART 1

Explore recursion fundamentals by showing how summing an array is built from same-type big and small parts, base cases, and a recursive structure to build solutions.

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.

Explore implementing a Java recursive method to sum array elements up to a given index, using a base case at zero and recursive calls, with no loops.

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.

Generate the Fibonacci series via recursion by summing the previous two numbers, using base cases 0 and 1, and drill down to compute any nth term.

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.

Learn to print all values in a linked list by traversing from the head using a current pointer, looping until null, and printing each node's value to the output.

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 how to add a node at the beginning of a linked list by creating a new node, linking it to the current head, and updating the head reference.

Learn how to insert a new node at a specific index in a linked list by locating the previous node, updating next references, and using temporary 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 the last node in a linked list by traversing with a current pointer, locating the previous node, setting its next to null, and updating the tail.

Delete the first node from a linked list by moving the head pointer to the second node, disconnecting the original first node, and starting the list from the new head.

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 to reverse the existing stack using two temporary stacks by popping and pushing elements, then transferring back to achieve a reversed order and prepare for Java code.

Learn to reverse a stack in Java by moving data between three stacks using push, pop, and peak operations, with an iterative empty check and a reusable move method.

Write a custom stack insertion method for a given index without built-in methods, using a temporary stack to insert ten at the second position.

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.

Learn to find the minimum element in a stack using a parallel temporary stack, updating on push and pop, and retrieving the min with peak.

Implement a two-stack approach to track the minimum element in a stack with custom push and pop operations, updating a temporary stack to retrieve the minimal value.

Learn how to sort a stack in ascending or descending order using a temporary stack, while managing last-in, first-out behavior with push, pop, and peek operations.

Sort a given stack in Java using a temporary stack, by transferring elements one by one and inserting them in sorted order, then return the sorted stack for printing.

Practice checking whether a string containing brackets, square brackets, and curly braces is balanced using a stack. Learn to return true or false based on balance while iterating over characters.

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.

Explore queues and stacks by illustrating fifo versus lifo, showing enqueue at rear and dequeue from the front, and examine Java's queue interface with ready queue and priority queue implementations.

Learn to implement a queue using an array by coding enqueue and dequeue operations, managing front and rear pointers, and preserving first-in, first-out behavior.

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

Learn to implement queue operations using a stack by constructing a hybrid data structure in Java, using an auxiliary stack to simulate dequeue.

Implement a queue in Java by using two stacks, transferring elements via a temporary stack to achieve FIFO behavior, enabling enqueue and dequeue through push and pop.

Explore Java's queue interface and its inbuilt implementations like ArrayDeque, using methods such as add, remove, poll, peek, and offer, including double-ended behavior.

Tackle the assignment to reverse a queue using a single temporary data structure, producing the output seven, nine, 12 and solving with examples.

Learn to reverse a queue using a single temporary stack by moving elements from the queue to the stack and back, demonstrating data structure mastery with push and pop operations.

Explore how a priority queue implements the queue interface, inserting elements by priority so the smallest value has highest priority, enabling fast removal and a sorted internal order.

Implement a priority queue enqueue using arrays by inserting at the correct position from the right. Practice scanning from the end and shifting elements to preserve order.

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.

Analyze how constant time (O(1)) operations compare with linear time (O(n)) using array and linked list examples, and how best and worst cases influence code efficiency.

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.

Analyze polynomial time with outer and inner loops producing O(n^2) operations, compare linear, logarithmic, exponential, and factorial time, and explore examples like multi-dimensional arrays and binary search.

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.

Explore selection sort by repeatedly finding the smallest element in the unsorted portion and swapping it into place, using an outer loop and an inner scan from i to end.

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.

This lecture introduces merge sort as a divide-and-conquer algorithm that uses recursion to split a list into left and right halves until single-element arrays and merge them.

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.

Master the merge of two arrays using recursion by tracking i, j, and k, comparing elements, filling a result array, and handling remaining elements in Java.

Learn how to implement merge sort in Java end to end, including splitting into left and right, recursive sorting, and merging to achieve O(n log n) time.

Explore linear search as a simple array lookup, implement a linear search method, and analyze best and worst case time complexities to compare with binary and jump search.

Master binary search on a sorted array by using the middle element and left and right pointers to halve search space, applying divide and conquer and understanding log time complexity.

Learn binary search on a sorted array via divide and conquer, using left, right, and middle indices to locate a target and handle not-found cases; include iterative and recursion approaches.

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.

Explore how binary search trees manage insertion by placing lesser values to the left and greater values to the right, and how in-order traversal yields a sorted sequence.

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.

Learn to insert a new node into a binary search tree using recursion, comparing to the root, moving left or right, and handling the base case.

Learn to implement a binary search tree in Java with a node class, left and right pointers, and a recursive insert method, including base cases and sorted-order traversal.

Traverse a binary search tree using an inorder traversal via recursion to extract and print values in sorted order, utilizing left smaller and right greater BST properties.

Traverse to the leftmost node in a binary search tree to locate the minimum element and return its value, achieving O(log n) time.

Demonstrate extracting the minimum and maximum elements from a binary tree via leftmost and rightmost traversal, using the root to guide the process.

Learn how to compute the height of a binary search tree using recursion, by comparing left and right subtree heights and returning the maximum plus one.

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.

Search for an element in a binary search tree by comparing with the root, recursing left or right, and return true when found, false when not, achieving log n time.

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 handles size, capacity, and load factor, including how clear, remove, and replace modify entries and how size differs from capacity.

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.

Explore how hash maps resolve collisions with a linked list in a bucket, trigger rehashing and bucket doubling, and adjust load factor to maintain O(1) average time.

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.