Top 20 Data Structure Interview Questions

▎Data Structures - Essential Guide

In this post, we will explore some fundamental data structures that are crucial for efficient programming. Understanding these data structures is essential for solving complex problems effectively.

1. Arrays:
• Description: A collection of elements identified by index or key.
• Time Complexity:
– Access: O(1)
– Search: O(n)
– Insertion/Deletion: O(n)
• Use Cases: Storing a fixed-size sequential collection of elements.

2. Linked Lists:
• Description: A linear collection of data elements, where each element points to the next, allowing for efficient insertion and deletion.
• Types:
– Singly Linked List
– Doubly Linked List
– Circular Linked List
• Time Complexity:
– Access: O(n)
– Search: O(n)
– Insertion/Deletion: O(1) (at the head)
• Use Cases: Dynamic memory allocation, implementing stacks and queues.

3. Stacks:
• Description: A collection of elements that follows the Last In First Out (LIFO) principle.
• Operations:
– Push: Add an item to the top.
– Pop: Remove the item from the top.
– Peek: View the top item without removing it.
• Time Complexity:
– All operations: O(1)
• Use Cases: Function call management, expression parsing, backtracking algorithms.

4. Queues:
• Description: A collection of elements that follows the First In First Out (FIFO) principle.
• Operations:
– Enqueue: Add an item to the back.
– Dequeue: Remove an item from the front.
• Time Complexity:
– All operations: O(1)
• Use Cases: Scheduling tasks, breadth-first search in graphs.

5. Hash Tables:
• Description: A data structure that implements an associative array, a structure that can map keys to values.
• Time Complexity:
– Average case for Search, Insert, Delete: O(1)
– Worst case (when collisions occur): O(n)
• Use Cases: Implementing dictionaries, caching data.

6. Trees:
• Description: A hierarchical structure with nodes connected by edges. The top node is called the root, and each node may have child nodes.
• Types:
– Binary Tree
– Binary Search Tree (BST)
– AVL Tree
– Red-Black Tree
• Time Complexity:
– Search/Insert/Delete in a balanced BST: O(log n)
• Use Cases: Representing hierarchical data, implementing search algorithms.

7. Graphs:
• Description: A collection of nodes (vertices) connected by edges. Graphs can be directed or undirected.
• Representation Methods:
– Adjacency Matrix
– Adjacency List
• Time Complexity:
– Varies depending on the algorithm used (e.g., DFS, BFS).
• Use Cases: Social networks, routing algorithms.

JavaScript Coding Interview Questions

Easy

1. Find the second smallest number in an array.
2. Reverse the order of words in a sentence.
3. Check whether a string starts and ends with the same character.
4. Find the average of numbers in an array.
5. Find all numbers that appear more than once in an array.
6. Replace every space in a string with a hyphen.
7. Find the longest common prefix among an array of strings.
8. Check whether an array is sorted in ascending order.
9. Find the index of the first occurrence of a given value without using indexOf().
10. Separate even and odd numbers into two arrays.
11. Find the difference between the largest and smallest values in an array.
12. Remove a specific element from an array without using filter().
13. Convert an array of numbers into an array of their squares.
14. Find the number of words in a sentence.
15. Swap two variables without using a temporary variable.


Medium

16. Implement a function that converts a nested object into a flat object.
17. Create a function that groups an array of objects by multiple properties.
18. Implement a function that removes duplicate objects from an array based on a property.
19. Write a function that compares two arrays regardless of their order.
20. Implement a custom version of Array.prototype.find().
21. Implement a custom version of Array.prototype.some().
22. Implement a custom version of Array.prototype.every().
23. Create a function that splits an array into chunks of a given size.
24. Implement a function that shuffles an array fairly.
25. Create a countdown timer using setInterval().
26. Implement a timeout wrapper for a Promise.
27. Write a function that caches the result of asynchronous operations.
28. Create a function that executes asynchronous tasks sequentially.
29. Implement a simple rate limiter for function calls.
30. Write a function that waits for multiple Promises but returns only the successful results.
31. Implement a custom deep-equality function for JavaScript objects.
32. Create a function that detects whether two strings are rotations of each other.
33. Implement a function that converts a JavaScript object into FormData.
34. Create a search function that filters and ranks objects based on a user's query.


Hard

35. Implement a simplified version of Promise.any().
36. Build a priority queue using JavaScript classes.
37. Implement a trie data structure for autocomplete.
38. Build a dependency resolver that determines the correct execution order of tasks.
39. Implement a simplified JavaScript module system with import and export behavior.
40. Build a worker pool that limits how many asynchronous tasks can run at the same time.

If you’re a fresher and you’re in 3rd/4th year but still don’t know coding, don’t start with LeetCode Hard.

Get these questions down first. A lot of service-based companies test these basic coding problems in fresher interviews:

1. Reverse a string without using a built-in reverse function
2. Check whether a string or number is a palindrome
3. Find the largest and smallest element in an array
4. Find duplicate elements in an array
5. Find the second-largest element without sorting
6. Check whether a number is prime
7. Print the first N Fibonacci numbers
8. Find factorial using recursion
9. Check whether two strings are anagrams
10. Count the frequency of each character in a string
11. Find the missing number from 1 to N
12. Find two numbers whose sum equals a target

You don’t need to know everything.

Try to solve these confidently first.

5 DSA Patterns in Coding Interviews

🔥 SQL Interview Case Studies (Advanced Business Scenarios)

🧠 Case Study 1: Find Repeat Customers
📊 Orders Table
order_id customer_id
1 101
2 102
3 101

❓ Business Question
Find customers who placed more than 1 order.

✅ Solution
SELECT customer_id,
COUNT(*) AS total_orders
FROM orders
GROUP BY customer_id
HAVING COUNT(*) > 1;

🧠 Case Study 2: Highest Paid Employee Per Department
❓ Business Question
Find highest paid employee in every department.

✅ Solution
WITH RankedEmployees AS (
SELECT *,
ROW_NUMBER() OVER(
PARTITION BY department
ORDER BY salary DESC
) rn
FROM employees
)
SELECT *
FROM RankedEmployees
WHERE rn = 1;

🧠 Case Study 3: Find Inactive Customers
❓ Business Question
Customers who haven't ordered in the last 6 months.

✅ Solution
SELECT c.customer_id,
c.name
FROM customers c
LEFT JOIN orders o
ON c.customer_id = o.customer_id
GROUP BY c.customer_id, c.name
HAVING MAX(o.order_date) <
DATE_SUB(CURDATE(), INTERVAL 6 MONTH);

🧠 Case Study 4: Product Generating Highest Revenue
📊 Sales Table
product_id amount

✅ Solution
SELECT product_id,
SUM(amount) AS revenue
FROM sales
GROUP BY product_id
ORDER BY revenue DESC
LIMIT 1;

🧠 Case Study 5: Employee Salary Above Department Average

✅ Solution
WITH DeptAvg AS (
SELECT department,
AVG(salary) avg_salary
FROM employees
GROUP BY department
)

SELECT e.*
FROM employees e
JOIN DeptAvg d
ON e.department = d.department
WHERE e.salary > d.avg_salary;

🧠 Case Study 6: Running Total Sales
❓ Business Question
Calculate cumulative sales.

✅ Solution
SELECT order_date,
amount,
SUM(amount) OVER(
ORDER BY order_date
) AS running_total
FROM sales;

🧠 Case Study 7: Top 3 Products Per Category

✅ Solution
WITH RankedProducts AS (
SELECT *,
ROW_NUMBER() OVER(
PARTITION BY category
ORDER BY sales DESC
) rn
FROM products
)
SELECT *
FROM RankedProducts
WHERE rn <= 3;

🎯 Practice Tasks
1️⃣ Find customer with highest number of orders
2️⃣ Find lowest salary employee per department
3️⃣ Find products never sold
4️⃣ Find departments with average salary > company average
5️⃣ Find month with lowest sales

⚡️ Mini Challenge 🔥
Banking Scenario
Tables:
Accounts
account_id customer_name

Transactions
transaction_id account_id amount transaction_date

Question
👉 Find the top 3 customers with highest total transaction amount in the last 1 year.

🔥 Interview Tip
When solving case studies:
1️⃣ Understand business question
2️⃣ Identify tables
3️⃣ Identify JOINs
4️⃣ Identify Aggregations
5️⃣ Decide whether Window Function is needed