LeetCode Algorithm Refresh: Reversals

Reverse an integer's digits while correctly handling 32-bit signed integer overflow.

Analyze number properties under digit reversal, such as the effect of leading zeros and double reversal invariance.

Reverse all bits of a 32-bit unsigned integer using bitwise shift and mask operations.

Apply XOR properties (cancellation, self-inverse) to solve problems involving pairing, toggling, or finding unique elements.

Reverse a singly linked list using an iterative three-pointer approach.

Reverse a singly linked list using recursion, understanding the call stack's role.

Reverse a sublist within a linked list between two given positions in a single pass.

Reverse nodes in fixed-size groups of 'k', handling the final, possibly smaller, group.

Reverse nodes in variable-sized groups based on a given condition (e.g., even-length groups).

Traverse an immutable linked list in reverse using an O(sqrt(n)) space optimization.

Evaluate expressions in Reverse Polish Notation (RPN) using a stack.

Solve problems involving nested structures, like reversing substrings between matched parentheses, using a stack.

Simulate ordering and selection processes, such as the 'Reveal Cards In Increasing Order' problem, using a deque.

Select between a stack or a deque to model a simulation based on access pattern requirements (LIFO vs FIFO/double-ended).

Apply a fixed-size sliding window to compute aggregates (sum, max, etc.) over consecutive subarrays.

Use a variable-size sliding window to find the shortest or longest subarray that satisfies a given condition.

Combine a sliding window with a hash map to solve substring problems with character constraints (e.g., 'longest substring with k distinct characters').

Analyze problem constraints to determine whether a fixed-size, variable-size, or hybrid sliding window approach is most appropriate.

Determine if two arrays can be made equal by reversing subarrays using frequency counting with hash maps.

Count the number of distinct integers in an array after applying a transformation (e.g., digit reversal) to each element, using a hash set.

Use a hash set to efficiently detect the existence of common substrings between a string and its reverse.

Group elements by a computed property (e.g., vowel count per word) using a hash map for subsequent processing.

Implement binary search to find a target, or the leftmost/rightmost occurrence of a value in a sorted array.

Apply binary search on the answer space to solve optimization problems (e.g., 'minimize the maximum').

Analyze the structure of merge sort to understand how custom logic can be injected during the merge step.

Count 'reverse pairs' in an array (where nums[i] > 2*nums[j] for i < j) by modifying the merge sort algorithm.

Implement recursive pre-order, in-order, and post-order traversals for a binary tree.

Validate if a binary tree is a valid Binary Search Tree (BST) by leveraging the properties of an in-order traversal.

Perform a Breadth-First Search (BFS) level-order traversal and collect nodes grouped by their level.

Reverse node values at specified levels (e.g., odd levels) of a binary tree using BFS and a temporary data store.

Use Python's `heapq` module for min-heap operations and simulate a max-heap by negating values.

Find the k-th largest element in a stream of data using a fixed-size min-heap.

Merge k sorted lists or arrays efficiently using a min-heap.

Maintain the median of a data stream by balancing a max-heap and a min-heap.

Solve interval scheduling problems (e.g., 'Meeting Rooms II') by using a min-heap to track event priorities.

Implement Breadth-First Search (BFS) and Depth-First Search (DFS) on a 2D grid.

Implement BFS and DFS for a graph represented by an adjacency list.

Solve shortest path problems in unweighted graphs and grids using BFS.

Count connected components in a grid (e.g., 'Number of Islands') using either BFS or DFS.

Detect a cycle in an undirected graph using DFS with parent tracking.

Detect a cycle in a directed graph using DFS by tracking nodes on the current recursion path.

Perform topological sorting on a Directed Acyclic Graph (DAG) using Kahn’s algorithm (BFS with in-degrees).

Implement Dijkstra’s algorithm with a priority queue to find the shortest paths in a weighted graph with non-negative edges.

Model an edge reversal problem as a shortest path problem by assigning 0/1 weights to edges.

Solve shortest path problems on 0/1 weighted graphs efficiently using a deque (0-1 BFS).

Solve 1D DP problems (e.g., 'Climbing Stairs', 'House Robber') using bottom-up tabulation, with space optimization.

Solve common 2D grid-based DP problems, such as 'Unique Paths' or 'Minimum Path Sum'.

Solve the Longest Common Subsequence (LCS) problem for two strings using a 2D DP table.

Solve the 0/1 Knapsack problem using tabulation to maximize value within a weight constraint.