Frontend focused interviews often don’t care about DSA at all.
And for those of us that remember studying DSA at school/college, all the examples felt purely algorithmic (for good reason), but there were hardly any examples or guidance on how the products we use every day leverage this concept.
“Will I ever need this?”
You’ve asked this a lot, haven’t you? 👀
Here are a few data structures that you can leverage in your React app today! 👇
Table of Contents
- Introduction
- Arrays: Your Go-to in State Management
- Objects and Hash Maps: Normalized Data Store for Efficiency
- Doubly Linked Lists: Navigation with Context
- Stacks: Undo/Redo Functionality with Immutable Behavior
- Queues: Managing Sequential API Calls
- Trees: Rendering Recursive Components
- Graphs: Building Complex Data Relationships and Navigation
- Conclusion
Related reading:
1. Arrays 🧩: Your Go-to in State Management
Arrays are everywhere in React. If you need help understanding how .map() or .filter() work, you’re probably seeing this post a little too soon! But don’t worry—once you get comfortable with these array methods, you’ll see how essential they are for rendering lists, managing component states, and transforming data.
2. Objects and Hash Maps 🗺️: Normalized Data Store for Efficiency
In a React app, when you deal with a large collection of entities like users or posts, normalizing your data into objects (hash maps) can make reading and updating much more efficient. Instead of working with a deeply nested structure, you map entities by their IDs.
Example: Reading from a normalized store with IDs
const postsById = {
1: { id: 1, title: 'First Post', content: 'Content of first post' },
2: { id: 2, title: 'Second Post', content: 'Content of second post' }
};
const postIds = [1, 2];
function PostList() {
return (
<div>
{postIds.map(id => (
<Post key={id} post={postsById[id]} />
))}
</div>
);
}
function Post({ post }) {
return (
<div>
<h2>{post.title}</h2>
<p>{post.content}</p>
</div>
);
}
This pattern allows for efficient data access, especially with large datasets where updates or reads need to happen quickly without re-rendering the entire collection.
3. Doubly Linked Lists 🔗: Navigation with Context
Doubly linked lists are useful when you need context from both the previous and next elements—think of navigating a photo gallery where each image displays its neighboring images for reference. Instead of using an index, we'll store the current node directly in the component state.
Example: Doubly linked list for navigation between elements with context
class Node {
constructor(value) {
this.value = value;
this.next = null;
this.prev = null;
}
}
class DoublyLinkedList {
constructor() {
this.head = null;
this.tail = null;
}
add(value) {
const newNode = new Node(value);
if (!this.head) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
newNode.prev = this.tail;
this.tail = newNode;
}
}
}
const imageList = new DoublyLinkedList();
imageList.add({ id: 1, src: 'image1.jpg', alt: 'First Image' });
imageList.add({ id: 2, src: 'image2.jpg', alt: 'Second Image' });
imageList.add({ id: 3, src: 'image3.jpg', alt: 'Third Image' });
function Gallery() {
const [currentNode, setCurrentNode] = useState(imageList.head);
return (
<div>
{currentNode.prev && (
<img src={currentNode.prev.value.src} alt={currentNode.prev.value.alt} className="prev-image" />
)}
<img src={currentNode.value.src} alt={currentNode.value.alt} className="main-image" />
{currentNode.next && (
<img src={currentNode.next.value.src} alt={currentNode.next.value.alt} className="next-image" />
)}
<div>
<button onClick={() => setCurrentNode(currentNode.prev)} disabled={!currentNode.prev}>
Previous
</button>
<button onClick={() => setCurrentNode(currentNode.next)} disabled={!currentNode.next}>
Next
</button>
</div>
</div>
);
}
In this React component:
- The current node is stored in the state, and the UI updates based on whether there’s a previous or next node.
- The buttons enable users to navigate the list both forwards and backwards, and disable if there’s no more nodes to move to.
- This structure simulates real-time navigation with context from the surrounding elements, commonly used in UI components like carousels, media galleries, or playlists.
4. Stacks 🚀: Undo/Redo Functionality with Immutable Behavior
Stacks allow you to manage undo/redo operations efficiently using Last In, First Out (LIFO) logic. By using immutable operations (concat, slice), we can ensure state remains unmutated.
Example: Undo/Redo with immutable push and pop
const [undoStack, setUndoStack] = useState([]);
const [redoStack, setRedoStack] = useState([]);
const [formState, setFormState] = useState({ name: '', email: '' });
const updateForm = (newState) => {
setUndoStack(prev => prev.concat([formState])); // Immutable push
setRedoStack([]); // Clear redo stack
setFormState(newState);
};
const undo = () => {
if (undoStack.length > 0) {
const lastState = undoStack.at(-1);
setUndoStack(prev => prev.slice(0, -1)); // Immutable pop
setRedoStack(prev => prev.concat([formState])); // Move current state to redo
setFormState(lastState);
}
};
const redo = () => {
if (redoStack.length > 0) {
const lastRedo = redoStack.at(-1);
setRedoStack(prev => prev.slice(0, -1)); // Immutable pop
setUndoStack(prev => prev.concat([formState])); // Push current state to undo
setFormState(lastRedo);
}
};
5. Queues 📬: Managing Sequential API Calls
Queues operate in a First In, First Out (FIFO) manner and are great for ensuring that tasks like API calls or notifications are processed in the correct order.
Example: Queueing API calls
const [apiQueue, setApiQueue] = useState([]);
const enqueueApiCall = (apiCall) => {
setApiQueue(prevQueue => prevQueue.concat([apiCall])); // Immutable push
};
const processQueue = () => {
if (apiQueue.length > 0) {
const [nextCall, ...restQueue] = apiQueue;
nextCall().finally(() => setApiQueue(restQueue)); // Immutable pop
}
};
6. Trees 🌳: Rendering Recursive Components
Trees are commonly used in React when dealing with nested components like comment threads, folder structures, or menus.
Example: Rendering a comment tree recursively
const commentTree = {
id: 1,
text: "First comment",
children: [
{ id: 2, text: "Reply to first comment", children: [] },
{ id: 3, text: "Another reply", children: [{ id: 4, text: "Nested reply" }] }
]
};
function Comment({ comment }) {
return (
<div>
<p>{comment.text}</p>
{comment.children?.map(child => (
<div style={{ paddingLeft: '20px' }} key={child.id}>
<Comment comment={child} />
</div>
))}
</div>
);
}
Another popular post that might be relevant to you:
7. Graphs 🎯: Building Complex Data Relationships and Navigation
Example 1: Routing between multiple views
You can represent routes between pages as a graph, ensuring flexible navigation paths in an SPA.
const routesGraph = {
home: ['about', 'contact'],
about: ['home', 'team'],
contact: ['home'],
};
function navigate(currentRoute, targetRoute) {
if (routesGraph[currentRoute].includes(targetRoute)) {
console.log(`Navigating from ${currentRoute} to ${targetRoute}`);
} else {
console.log(`Invalid route from ${currentRoute} to ${targetRoute}`);
}
}
Example 2: User relationship modeling
Graphs are perfect for modeling social connections or any kind of relationship where multiple entities are interconnected.
const usersGraph = {
user1: ['user2', 'user3'],
user2: ['user1', 'user4'],
user3: ['user1'],
user4: ['user2']
};
function findConnections(userId) {
return usersGraph[userId] || [];
}
console.log(findConnections('user1')); // Outputs: ['user2', 'user3']
Note: We use graphs to show reviewer dependencies in Middleware.
TL;DR — Those School Lessons Pay Off
Those DSA classes might have felt abstract back in the day, but data structures are powering the world around you in React.
Objects, stacks, queues, linked lists, trees, and graphs are more than just theory — they’re the backbone of the clean, efficient, and scalable apps you build every day.
So the next time you manage state in a queue or handle complex UI logic, remember: you’ve been training for this since school. 💪
Let me know which data structures you’ve been using the most!
Top comments (37)
Single and doubly linked lists.
And treeeees! 🌳
Hello. What do you use singly linked lists for?
Good one!
Thanks John! :)
Insightful 🦚
Glad to hear it 🚀
Reminded me of this quote. “Data dominates. If you've chosen the right data structures and organized things well, the algorithms will almost always be self-evident. Data structures, not algorithms, are central to programming” - Rob Pike
Hard agree! ❤️
Great article!
nice blog
Thank you! :)
With the popularity of existing, ready-to-use frameworks, I doubt this is highly useful when implementing DSA using class components over the more common function components
You don't have to implement DSA using class components. :)
My examples show DSA implementations using classes, but I've personally used these in function components since I've not made class components in... years I think.
Where is this coming from? I don't see any class components mentioned or shown. Also, what's up with the class component hate? There are some types of more advanced components that you have to bend over backwards to implement in functional components, which are magnitudes easier with class components. Use the best tool for the job. Class components are deprecated.
Appropriate in every job. :)
Nice, simplified but make sense
Glad it made sense for you. I sometimes feel I might be overexplaining things. :D
I really like this, especially since I've been wanting to dive deep into DSA but haven't found the time yet. This post gave me a great head start! :)
Perfect 👍
Thanks!
This is a a great article!
Can also practise questions on PrepareFrontend platform
PrepareFrontend.com
Some comments may only be visible to logged-in visitors. Sign in to view all comments.