This content originally appeared on DEV Community and was authored by Jayant Bhawal
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
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>
);
}
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!
This content originally appeared on DEV Community and was authored by Jayant Bhawal
Jayant Bhawal | Sciencx (2024-09-08T09:01:48+00:00) Frontend Dev + Data Structures & Algorithms: How DSA Can Power Your React App ⚡. Retrieved from https://www.scien.cx/2024/09/08/frontend-dev-data-structures-algorithms-how-dsa-can-power-your-react-app-%e2%9a%a1/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.