Fill Missing Data - Solution & Explanation
Problem Statement
DataFrame products
+-------------+--------+
| Column Name | Type |
+-------------+--------+
| name | object |
| quantity | int |
| price | int |
+-------------+--------+
Write a solution to fill in the missing value as 0 in the quantity column.
The result format is in the following example.
Example 1: Input:+-----------------+----------+-------+ | name | quantity | price | +-----------------+----------+-------+ | Wristwatch | None | 135 | | WirelessEarbuds | None | 821 | | GolfClubs | 779 | 9319 | | Printer | 849 | 3051 | +-----------------+----------+-------+ Output: +-----------------+----------+-------+ | name | quantity | price | +-----------------+----------+-------+ | Wristwatch | 0 | 135 | | WirelessEarbuds | 0 | 821 | | GolfClubs | 779 | 9319 | | Printer | 849 | 3051 | +-----------------+----------+-------+ Explanation: The quantity for Wristwatch and WirelessEarbuds are filled by 0.
Approach Overview
Problem Overview: You receive a sequence containing missing or placeholder values. The task is to scan the data and replace those missing entries with valid values based on a defined rule, typically derived from surrounding elements or previously seen data.
Approach 1: Iterate and Replace Using Conditional Logic (Time: O(n), Space: O(1))
The direct solution is a single pass through the sequence. While iterating, check each element for a missing marker such as null, None, or a sentinel value. When a missing entry appears, replace it using the rule defined by the problem (commonly the last valid value seen or another computed fallback). This approach relies on simple array traversal and conditional checks, so the logic stays predictable and efficient.
Because the array is processed once and updates are done in place, the time complexity is O(n) and the space complexity is O(1). This method is reliable for interview settings since it demonstrates strong control over iteration and state tracking.
Approach 2: Use Built-In Functions or Libraries (Time: O(n), Space: O(1) to O(n))
Many languages provide utilities that simplify missing-value handling. For example, libraries may offer forward-fill or replace operations that automatically propagate valid values into missing slots. Internally these functions still perform a sequential scan, but they hide the explicit loop and conditional checks from the user.
This approach keeps the time complexity at O(n) because the dataset must still be processed element by element. Space usage depends on the implementation: in-place replacements use O(1) space, while functions that return a new structure may require O(n). It works well in production code where readability and reliability matter more than manually implementing iteration.
Recommended for interviews: Start with the explicit iteration approach. Interviewers expect you to control the scan, track the last valid value, and update missing entries as you go. The built-in function approach is useful in real-world data processing, but writing the logic yourself demonstrates stronger understanding of array processing and sequential iteration.
Approach 1: Iterate and Replace Using Conditional Logic
This method involves iterating over each row of the DataFrame. We check if the 'quantity' value is null (or equivalent) and set it to zero if it is. This is a straightforward approach that uses conditional checks within loops appropriate for each programming language.
In this C code, we define an array of structs, each representing a product. The quantity is assumed to be -1 when missing. The function fillMissingQuantities iterates over the products and sets any -1 quantity to 0. Finally, we print out the updated products.
Complexity
Time Complexity: O(n), where n is the number of products.
Space Complexity: O(1), as we do not use additional space proportional to the input size.
Approach 2: Use Built-In Functions or Libraries
This approach involves leveraging built-in functions or libraries available in programming languages, like pandas in Python or LINQ in C#, to perform the task of filling in missing values effectively and efficiently.
Here, we stick with the manual way as C does not have a specific library for DataFrame handling. We assume -1 indicates a missing value, replaced by 0.
Complexity
Time Complexity: O(n), where n is the number of products.
Space Complexity: O(1), without additional space for the task.
Approach 3: Default Approach
Code
Python
Complexity Comparison
| Approach | Complexity |
|---|---|
| Iterate and Replace Using Conditional Logic | Time Complexity: O(n), where n is the number of products. |
| Use Built-In Functions or Libraries | Time Complexity: O(n), where n is the number of products. |
| Default Approach | — |
Detailed Complexity Analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Iterate and Replace Using Conditional Logic | O(n) | O(1) | Best for interviews and when you want full control over how missing values are handled |
| Use Built-In Functions or Libraries | O(n) | O(1) to O(n) | Useful in production environments where standard library utilities simplify data cleaning |
Video Solution
Fill Missing Data LeetCode 2887 • CuteLeetCrafter • 249 views views
Watch 3 more video solutions →Frequently Asked Questions
Is Fill Missing Data easy or hard?
Fill Missing Data Python/Java solution
How to solve Fill Missing Data in O(n)?
What is the best approach for Fill Missing Data?
Is Fill Missing Data asked at Google/Amazon/Meta?
What data structure is used in Fill Missing Data?
What is the time complexity of Fill Missing Data?
Ready to solve this problem?
Practice Fill Missing Data with our built-in code editor and test cases.
Practice on FleetCodeTable of Contents
Practice this problem
Open in Editor