Data Structures and Algorithms Complete Course - CPP & JAVA

Learn asymptotic analysis with notations like theta and big O to measure time growth with input size n, independent of language or machine, focusing on worst-case behavior and growth rates.

Learn how to analyze algorithms to compare different solutions for the sum of first n natural numbers. Discover asymptotic analysis as a theoretical guide to choosing the most efficient approach.

Learn how to compare algorithm efficiency using order of growth as n tends to infinity, ignoring constants, and comparing leading terms like f_n, g_n, n, log n, and n^2.

Explore best, average, and worst cases in algorithms, and analyze order of growth using array sum examples to illustrate constant and linear time depending on input.

Explore asymptotic notations—the big O, theta, and omega—and how they express upper, exact, and lower bounds of time growth, using linear search examples and best to worst case.

Explore how big o notation expresses upper bounds on growth, when to use theta for exact bounds, and how to ignore lower order terms in determining order of growth.

Discover how omega notation provides a lower bound on algorithm time and contrasts with Big-O. See examples like initializing scores for n players and printing permutations to illustrate the bound.

Theta notation provides the exact bound on an algorithm’s growth by bounding from both sides with two constants, linking to big-o and omega when growth is exact.

Analyze common loops and determine time complexity, from linear theta(n) to logarithmic and log log n growth, noting that log base does not matter and constants are ignored.

Explore analysis of multiple loops, including sequential and nested patterns, and determine time complexities such as theta n, theta log n, and theta n squared for inputs n and m.

Analyze the time complexity of recursive codes by formulating recurrence relations with two recursive calls on n/2 and a constant base case, t(0) is theta(1).

Draw the recursion tree to solve recurrences, count work at each level, identify the pattern, and show the total runtime is theta n log n for two recursive calls.

Use the recursion tree method to solve recurrences, analyze work per level, and apply a geometric series to obtain theta bounds with binary search and Tower of Hanoi examples.

Derive an upper bound using a full recursion tree and a geometric progression with ratio 3/4, giving O(n).

Learn how space complexity measures memory growth with input size, distinguish auxiliary space from overall space, and compare constants, linear, and recursive approaches using Fibonacci and sorting examples.

Count digits in a positive integer by dividing by ten until zero, incrementing a counter each step; works in C++ and Java with theta d time.

Determine whether a non-negative number is a palindrome by reversing its digits and comparing the reverse to the original number, returning true or false.

Compute the factorial of a nonnegative n by multiplying 1 through n, with base cases at 0 and 1, comparing iterative theta(n) with O(1) space to recursive theta(n) space.

Count trailing zeros in n! by counting factors of five in its prime factorization, using n/5, n/25, and n/125, to obtain a log n time solution without overflow.

Learn how to compute the greatest common divisor of two numbers using the Euclid algorithm, including naive approaches, time complexities, and the optimized modulo form with examples.

Learn how to compute the lcm of two numbers, using a naive incrementing method and an efficient gcd-based approach via the Euclidean algorithm, with time complexity analysis.

Explore prime checking by moving from a naive 2 to n-1 test to an efficient sqrt(n) approach, skipping even numbers and multiples of three using a 6k±1 pattern.

learn to extract prime factors by dividing n by its smallest prime factors up to the square root, printing repeated factors, and comparing naive and optimized sqrt-based methods.

Explore efficient techniques to print all divisors of a number in increasing order by leveraging divisor pairs, sqrt(n) time, and a two-loop approach.

Learn the sieve of Eratosthenes to list all primes up to n, using a boolean isprime array and marking multiples, with i squared optimization and O(n log log n) time.

Compute x raised to n using exponentiation by squaring, contrasting a theta(n) naive loop with a theta(log n) recursive approach for even and odd n.

Present an iterative exponentiation by squaring using binary representation of n. Multiply the result by x when a bit is 1, square x each step, achieving O(log n) time and O(1) space.

Explore bitwise operators in C++ by examining and, or, and xor, applied to binary representations of integers like 3 and 6; learn bit-by-bit rules and 32-bit context.

Explore bitwise operators in cpp, including left shift, right shift, and bitwise not, with examples of multiplying or dividing by powers of two and notes on unsigned versus signed behavior.

Explore bitwise operators in Java by applying bitwise and, bitwise or, and bitwise xor to binary representations of integers, illustrated with 3 and 6 yielding 2, 7, and 5 respectively.

Explore the bitwise not operator (tilde) and left shift operator in java, using binary and two's complement representations, with concrete examples like 1, 5, and minus two for clarity.

Explore signed and unsigned right shift operators in Java, showing sign extension for negatives and zero filling for unsigned shifts, within 32-bit two's complement representations.

explain how negative numbers are stored in binary via two's complement and the range -2^(n-1) to 2^(n-1)-1. show how to obtain two's complement by inverting bits and adding one.

Check if the kth bit in n is set using bitwise operations and show how left shift or right shift computes two raised to the power k minus one.

Count the set bits in a number using a naive bit-by-bit method, then adopt the Brian Cunningham algorithm and a 256-entry table to answer 32-bit counts in O(1) time.

Determine whether a number is a power of two using a one-line bitwise test, noting powers of two have a single set bit and zero is not.

Apply bitwise XOR across all numbers to find the single odd-occurring value in an array, as XOR cancels even occurrences in theta(n) time and O(1) space.

Explore a linear-time, constant-space approach using XOR to find the two odd occurring numbers in an array, compared to the naive quadratic method.

Generate power sets with an iterative bitwise approach, mapping binary representations 0 to 2^n−1 to subsets and printing each subset while avoiding recursion.

Explore recursion as a programming technique where a function calls itself, examine direct and indirect recursion, identify base cases, and learn the typical recursive function structure to ensure termination.

Unleash the power of recursion across dynamic programming, backtracking, and divide and conquer with concrete examples like lcs, edit distance, n-queens, dfs traversals, and file system search.

Trace recursion in C++ and Java programs from the main function to reveal outputs like 321123 and 1213121, understanding nested calls, prints, and the base case.

Practice recursion in data structures and algorithms with outputs for powers of two and non-powers, revealing how a function returns floor log base two. See how remainders yield the binary digits.

Explain printing numbers from one to n using recursion: solve for n minus one, then print n, with base case zero. Achieves theta(n) time and O(n) auxiliary space.

Learn to implement a recursive function that prints from n down to 1 with base case n equals zero, achieving theta(n) time and theta(n) auxiliary space.

Learn tail recursion and tail call elimination, see how modern compilers optimize by updating parameters and looping, and compare factorial, quicksort, merge sort, and in-order, pre-order, and postorder traversals.

Learn to write correct base cases in recursion using factorial and nth fibonacci examples, and prevent stack overflow or segmentation faults by avoiding wrong base cases.

This lecture shows summing the first n natural numbers via recursion, with base case zero, using sum(n)=sum(n-1)+n, a Java example, and theta(n) time and space, plus n(n+1)/2.

Learn to check palindromes with recursion by comparing first and last characters and recursing on the inner substring, with base cases for empty or single-character strings.

Learn to compute the sum of digits of a nonnegative number using recursion, removing the last digit with n/10 and adding n%10, with base case zero.

Determine the maximum number of rope pieces by cutting a rope of length n into a, b, or c using a recursive approach with base cases and dynamic programming.

Generate all subsets (subsequences) of a string using a recursive approach that includes or excludes each character. For length n, there are 2^n subsets, shown with ab and abc examples.

Solve the Tower of Hanoi by recursion: move n-1 disks from A to B, move the bottom disk from A to C, then move n-1 disks from B to C.

Learn the Josephus problem, where n people circle, every k-th person is killed, and the survivor's position is found via a recursive, zero-based solution using modulo.

Count all subsets of an array that sum to a given value using a recursive include-or-exclude approach, revealing that there are 2^n subsets and a base case sum zero.

Print all permutations of a string by fixing each character in turn, swapping to build subproblems, using recursion with an index and backtracking to restore the original string.

Discover how arrays store multiple items of the same type in contiguous memory, enabling constant-time random access by index and strong cache friendliness, unlike linked lists and self-balancing BSTs.

Contrasts fixed size and dynamic arrays, detailing stack and heap allocation and automatic resizing. Demonstrates dynamic arrays such as vector and ArrayList resize by doubling capacity for amortized constant-time inserts.

Discover why vectors in C++ outperform arrays by providing dynamic size, easy to know size, and rich library functions, along with safe return, default initialization, and simple copying.

ArrayList in Java is a dynamic sized array that grows as you add items, offering contains, add at end or by index, and remove, with capacity and construction from HashSet.

Explore array operations, including linear search and insertion with capacity constraints, analyze time complexity from O(n) to amortized O(1) for dynamic arrays, and note binary search in sorted arrays.

Delete an element from an array by locating the first occurrence, shifting later elements left, and reducing size while preserving capacity; theta n time and last-element deletion can be O(1).

Learn how to find the index of the largest element in an array, comparing the naive O(n^2) approach with a one-traversal method that updates the maximum.

Learn to find the second largest element in an array and return its index, handling duplicates and the no second largest case (-1) with a one-traversal solution using constant space.

Check if an array is sorted in non-decreasing order by comparing adjacent elements; return false if a[i] < a[i-1]. The linear-time, constant-space method handles empty or single-element arrays as sorted.

Learn in-place array reversal by swapping elements with two indices, low and high, moving toward each other, and analyze theta(n) time and theta(1) space.

Remove duplicates from a sorted array in place by keeping the first copy of each element at the front, preserving order, and returning the new size without deallocating space.

Move all zeros to the end while preserving the order of non-zero elements, using linear time, one traversal, constant extra space, and tracking the count of non-zero elements.

Learn to left rotate an array by one in place, moving each element left with a temporary variable, and placing first at the end, achieving theta(n) time and theta(1) space.

Explore left rotating an array by d positions with three approaches: a reversal-based theta(n) time, theta(1) space method, and a theta(n) time method using theta(d) space, plus d>n handling.

Identify leaders in an array by scanning from the right, maintaining the right-side maximum and printing elements strictly greater than it; the last element is always a leader.

Compute the maximum difference between array elements with j > i by sweeping left to right, tracking the minimum value seen so far and updating the result in theta(n) time.

Traverse a sorted array to compute and print each element's frequency in a single linear pass, handle corner cases, and note theta n time.

An introduction to the stock buy and sell problem with known future prices, showing how to maximize profit using a naive recursive solution that explores buy and sell pairs.

Learn the simple, efficient stock buy and sell approach: buy at bottoms, sell at peaks, and accumulate profit by summing positive differences as you traverse the price array.

Compute trapped rainwater for bar heights by precomputing left max and right max, then sum min(left max, right max) minus height for middle bars, achieving theta(n) time.

Discover how to count the maximum consecutive ones in a binary array. Implement a single-pass solution that resets the current count at zeros and updates the maximum.

Explore how to find the maximum sum of a contiguous subarray, using an efficient O(n) method that handles negative numbers and starts a new subarray or extends the previous maximum.

Identify the longest subarray with alternating even and odd numbers in a contiguous array, and compare a quadratic naive solution with a linear Kadane-inspired approach.

Discover how to compute the maximum circular subarray sum by combining Kadane's algorithm for normal subarrays with the minimum subarray trick, including an array inversion method, in linear time.

Find the majority element, appearing more than n by two times, and return any index or -1; Müller's voting algorithm uses two phases to verify.

flip the second group in the binary array to minimize flips, using a one-pass method that counts groups of zeros and ones and prints the flip ranges.

Explore the sliding window technique to compute the maximum sum of a subarray of size k in O(1) time per shift by updating the current window from the previous one.

Explore how to determine if a subarray with a given sum exists in an array of non-negative integers using a two-pointer sliding window, achieving linear time with constant space.

Learn the prefix sum technique to answer range sums in O(1) after a linear-time preprocessing, using a prefix sum array to compute sums for any L to R.

Identify whether an array has an equilibrium point by comparing left and right sums, and learn an efficient two-pass, constant-space solution.

Learn a linear-time method to find the maximum appearing element across left-right ranges by using a frequency array and a prefix-sum approach.

Explore iterative binary search on a sorted array to find an element’s index, return -1 when absent, and return any index when duplicates occur, using mid, low, and high.

Implement a recursive binary search on a sorted array, returning the index of a found element or -1, using mid, left and right halves, with base case low > high.

Analyze binary search on a sorted array, tracing mid, low, and high across iterations, and compare time complexity for successful and unsuccessful searches, both governed by log n.

Find the first occurrence of x in a sorted array with duplicates, returning its index or -1, using binary search (recursive and iterative) for log n time.

Find the last occurrence of x in a sorted array with binary search, returning -1 if not present, using recursive and iterative approaches with log n time and appropriate space.

Count the occurrences of x in a sorted array with duplicates by performing two binary searches to locate first and last occurrences, yielding log n time.

Use binary search to locate the first 1 in a sorted binary array, then count the ones as n minus firstOccurrence, achieving O(log n) time.

Learn to compute the floor of the square root of an integer, handling perfect squares and non-perfect squares, with a naive approach and a log x time binary search solution.

Explore searching in infinite sized sorted arrays using unbounded binary search, doubling indices to bound the range. Contrast naive O(position) with the efficient O(log position) method and understand time complexity.

Use binary search on a sorted rotated array, identify the sorted half, and locate the element in log n time with constant space, returning its index or minus one.

Find a peak element in an unsorted array using binary search, comparing the middle with neighbors, and narrowing to a half until a peak appears in O(log n) time.

Use the two-pointer technique on a sorted decreasing array to check if a pair sums to x, returning true or false. Move pointers inward in O(n) time and O(1) space.

Master the triplet in a sorted array by summing to x, moving from a naive O(n^3) approach to an O(n^2) two-pointer method with a pair-sum subroutine.

Learn to find the median of two sorted arrays by performing binary search on the smaller array and partitioning to equal halves, achieving logarithmic time.

Explore solving an array where every element appears once except one repeating element, with zero present and maximum determining the range, without modifying the array.

Discover a non-modifying, O(n) time and O(1) space cycle-detection method to find the single repeating element, using slow-fast pointers on arrays 1 to n-1 and adapting for zero-based cases.

Partition contiguous books among two or more students using a naive recursive solution to minimize the maximum pages read; illustrate with an example of 10, 20, 30, 40 pages.

Use a binary search based solution to allocate the minimum maximum pages per student for contiguously distributed books, checking feasibility by counting required students within a max to sum range.

Explore an overview of sorting algorithms, from quicksort and partition schemes to counting, radix, bucket, and shell sort, including stability, memory, and when to use each approach.

Master sorting in c++ stl by using the sort function on arrays, vectors, and deque, with iterators begin and end, default increasing order, and custom comparators for custom types.

Java sorting relies on arrays and collections. Primitives use dual pivot quicksort, while non-primitives use a stable merge sort based Tim sort adaptation to preserve original order.

Learn how Arrays.sort sorts primitive and non-primitive types in Java, using natural order, custom comparators, and subarray sorting, with guidance on stability and reverse order.

Sorts list collections with Collections.sort, showing natural and reverse orders for array list and linked list, and uses comparable and comparator for custom types.

Explore stability in sorting algorithms by comparing how equal keys maintain original order, with examples like bubble sort (stable) and selection sort (unstable) and practical implications for multi-field objects.

Explore bubble sort, a simple comparison-based algorithm with O(n^2) time that uses multiple passes to bubble the largest elements to the end, and learn its optimized, stable, in-place implementations.

Explore selection sort's basic idea and in-place, comparison-based approach, its theta(n^2) time in all cases, and its memory write characteristics and stability notes.

Split the input, sort the parts recursively, and merge them to form a stable, divide-and-conquer merge sort with theta(n log n) time and O(n) space.

Learn to merge two sorted arrays in linear time with a two-pointer approach, printing the merged sequence while preserving stability and using constant auxiliary space.

We merge two sorted subarrays in a merge sort by copying them to left and right buffers and merging back into the original array, achieving theta(n) time and theta(n) space.

Implement merge sort by dividing the array into two halves, recursively sorting each half, and merging them with a merge function to produce a sorted array, a divide-and-conquer approach.

Analyzes merge sort with a recursion tree, showing theta(n) work per level across theta(log n) levels for theta(n log n) time, and notes theta(n) auxiliary space with O(1) optimization options.

Explore insertion sort, an in-place, stable algorithm for small arrays that inserts each element into a sorted prefix, with best-case O(n) and worst-case O(n^2), used in hybrids like TimSort.

Learn to compute the intersection of two sorted arrays using a merge-like two-pointer approach, printing each common element once, handling duplicates, and yielding an empty output when none exist.

Learn to compute the union of two sorted arrays by merging them in linear time, printing each distinct element once in sorted order, with O(m+n) time and O(1) space.

Count inversions in an array by counting cross inversions during a merge sort, using count and merge, handling left and right halves, achieving O(n log n) time and O(n) space.

Understand the partition function of quicksort by partitioning around a pivot so smaller elements stay left and larger elements stay right. Compare naive, Lomuto, and Hoare partitions and their costs.

Explore Lomuto partition, which traverses the array once around a last-element pivot, swaps to place smaller elements left and greater elements right, achieving O(n) time and O(1) space.

Explains Hoare's partition method, which, unlike Lomuto, uses two indices and does not fix the pivot at its correct position, offering O(n) time and O(1) space.

Explore quicksort, a divide-and-conquer in-place sorting algorithm using a partition function to divide and sort subarrays, with lomuto and hoare partitions and tradeoffs versus merge sort.

Learn to implement quicksort using Lomuto partition by placing the pivot at its correct position and recursively sorting left and right subarrays. Also note how it differs from Hoare's partition.

Implement quicksort using Hoare's partition to divide around a pivot, place smaller on left and greater on right. Recursively sort the subarrays; Hoare's partition is faster but not stable.

Analyze quicksort performance across best, worst, and average cases, comparing Hoare's and Lomuto partitions and noting best and average are theta(n) log n while worst is theta(n^2).

Examine the auxiliary space of quicksort, comparing in-place partitioning options (Hoare or Lomuto) with recursion stack usage; note worst-case theta n and best-case theta log n.

Quicksort's analysis shows worst-case performance on sorted inputs for Lomuto and Hoare partitions; random pivots prevent this, giving expected O(n log n).

Explore tail call elimination in quicksort, showing how to replace the final recursive call with a loop using goto, and optimize extra space by recursing only on the smaller partition.

Find the kth smallest element in an unsorted array using a partition based approach with lomuto partition and a pivot in an iterative algorithm, outperforming naive O(n log n) sort.

Learn to compute the minimum difference in an array by comparing all pairs with a naive O(n^2) approach, then apply a sorting-based O(n log n) method that compares adjacent elements.

Sort the packet array, choose m packets, slide a window of size m to minimize the difference between the maximum and minimum, achieving fair distribution.

Sort an array with two element types, like negatives and positives or even and odd numbers, using Hoare's or Lomuto partitioning for theta(n) time and theta(1) space.

Explore sorting an array of zeros, ones, and twos; learn three-way partitioning around a pivot and range-based partitioning via the Dutch National Flag algorithm.

Merge overlapping intervals by sorting by start time, then iteratively merging with the previous interval using min start and max end, producing non-overlapping intervals.

Learn to maximize the number of guests met by analyzing arrival and departure times, sorting both lists, and merging events to track peak guest count in O(n log n).

Learn cycle sort, an in-place sorting algorithm with O(n^2) time and minimal memory writes, using cycles and counting smaller elements to place items, including minimum-swaps scenarios and duplicates handling.

Heapsort builds a max heap from the array and, by swapping the max with the end and heapifying, achieves n log n time and is an improvement over selection sort.

Counting sort uses a count array to tally each value in a small range, producing a stable, linear-time sort (O(n+k)) for integers or keyed objects and as radix sort subroutine.

Radix sort achieves linear time for data in a limited range by using counting sort as a stable subroutine to sort numbers by digits, not via comparisons.

Explains bucket sort, using uniform distribution across a range to divide data into buckets, sort each bucket, and join them for linear-time sorting, with worst-case when distribution fails.

Explore multidimensional arrays in C++, including 2D and 3D arrays, traversal with nested loops, row major storage, and dynamic implementations using double pointers and vectors.

Learn how to pass two-dimensional arrays as function arguments in C++, generalize matrix operations for any dimensions, and compare C-style and C++-style approaches, including vectors and pointers.

Discover how Java implements multidimensional arrays as arrays of arrays, including 2d and jagged forms, and learn to traverse with lengths, initialize values, and print in tabular form.

Pass a multi-dimensional array to a Java function by declaring a two-dimensional array (int[][]), then traverse rows with r.length and each row's columns with r[i].length to print elements.

Learn to print a matrix in a snake pattern by traversing rows alternately left-to-right and right-to-left, with theta(r*c) time complexity.

Learn boundary traversal of a matrix by printing the first row, last column, last row, and first column. Handle single row or column cases and note the time complexity theta(r+c).

Explore how to transpose a square matrix in place in one traversal by swapping upper diagonal elements with corresponding lower diagonal elements, preserving diagonal values and using no extra space.

Rotate a square matrix 90 degrees anticlockwise in place by first transposing it and then reversing each column, achieving theta(n^2) time with theta(1) auxiliary space.

Peel the matrix in spiral order by printing the top row, the right column, the bottom row in reverse, and the left column while updating top, bottom, left, and right.

Search a row-wise and column-wise sorted matrix for x using the top-right corner method, printing its position or not found, and contrast with the naive O(RC) approach.

Find the median of a row wise sorted odd-sized matrix using a value-based binary search across min and max, counting elements in each row with upper_bound.

Discover how to find the median in an odd-sized row-wise sorted matrix with distinct elements using a value-range binary search that counts elements per row with binary search.

Explore hashing as a fast dictionary and set implementation with search, insert, and delete in average O(1) time, and note its limits for closest values, range queries, and prefix search.

Discover how hashing powers dictionaries, database indexing, password hashing, caches, symbol tables, and router mac address lookups, with associative arrays underpinning rapid data access.

Explore the direct address table using a boolean array to achieve search, insert, and delete in O(1) for small key ranges, and note hashing as the next concept.

Contrast hashing functions with direct address table by converting large keys into hash table indices. Learn about collisions, and design rules like consistency, speed, and uniform distribution.

Explore how hash collisions arise in hash tables and why they are inevitable without prior knowledge of keys, the birthday paradox, and two collision-handling methods: chaining and open addressing.

Explore chaining as a collision-handling method in hash tables, using an array of linked list headers, exploring load factor, hash functions, and storage options like dynamic arrays and self-balancing bsts.

design a simple hashing scheme with chaining using an array of linked lists to resolve collisions, and implement insert, search, and delete operations across a bucket-based hash table.

Open addressing uses a single hash table to resolve collisions, offering linear, quadratic, and double hashing with cache-friendly lookups, and supports insertion, search, and delete operations.

Double hashing uses two hash functions, h1 and h2, to compute probe steps. If m is relatively prime to h2, a free slot is guaranteed when available.

Implement an open addressing hash table in a myhash class with capacity, using linear probing for insert, search, and erase, with minus one as empty and minus two as deleted.

Compare open addressing and chaining for hash tables, noting that chaining avoids lookup failures but may require resizing, while open addressing trades space for cache-friendly contiguous storage.

Explore unordered_set in the C++ STL, highlighting hashing-based storage, lack of order, and constant-time insert, find, erase, and count on average, with practical usage and common operations.

Explore unordered map in C++ STL, a hash-based container for fast key-value storage, insertion, lookup, and deletion, with iteration and common operations like find, count, and erase.

Explore hash set in Java, storing non-primitive keys with hashing and hash tables, enabling add, remove, and contains with average O(1) time and order-free traversal.

Explore how hash maps in Java store key-value pairs, perform creation and traversal, and use operations like get, put, remove, containsKey, and containsValue with average constant time.

Count distinct elements in an array by contrasting a naive O(n^2) approach with a linear-time solution using a hash set in C++ or Java, achieving theta(n) time and theta(n) space.

Compute frequencies of all array elements with a naive approach, then use a hash map to print each distinct element and its frequency in any order.

Compute intersection of two unsorted arrays with distinct elements, printing elements in the order of the first array. Contrast a naive O(mn) approach with the efficient O(m+n) hash set solution.

Count distinct elements across two unsorted arrays by inserting both arrays into a hash set, then return the set's size for a linear-time solution.

Investigate the pair-sum problem on an unsorted array with duplicates and negatives. Compare naive O(n^2) solutions with a hashing-based linear-time method that checks complements before insertion.

Detect a zero-sum subarray by using prefix sums and hashing to achieve linear time. Repeated prefix sums or a zero prefix indicate a zero-sum subarray.

Explore the subarray with a given sum problem by using prefix sums and hashing to find contiguous subarrays in linear time with linear auxiliary space via a hash table.

Learn to find the longest subarray with a given sum by using prefix sums and a hash map to store prefix sums and their indices, achieving linear time.

Learn to find the longest subarray with equal zeros and ones in a binary array by replacing zeros with minus ones and using prefix sums with hashing for linear time.

Identify the longest common subarray with the same sum in two binary arrays by transforming to a zero-sum subarray problem via a difference array, achieving linear time.

Solve the longest consecutive subsequence problem with two approaches: a sorting-based O(n log n) method and a linear-time hash set method using two lookups to find subsequence starts.

Learn to count distinct elements in every window of size k using a sliding window and a frequency map, achieving O(n) time and O(k) space.

Identify elements whose occurrences exceed n by k in an array, with examples and two approaches: sort-based counting and hash map frequencies, including time complexity notes.

Apply a generalized Moore voting approach to find elements with more than n/k occurrences. Use a process with a map of at most k−1 candidates and validation, in O(nk) time.