Bianca Gandolfo
Thumbtack
Course Description
In this course, Bianca Gandolfo — JavaScript consultant and returning Frontend Masters instructor — demonstrates how to organize and use data efficiently with data structures. Following along with the course, you'll learn to implement the most common data structures such as linked lists, hash tables, and stacks/queues. Plus, review and solve common technical interview questions through practice and solution walkthroughs!
This course and others like it are available as part of our Frontend Masters video subscription.
Preview
CloseCourse Details
Published: August 9, 2018
Learning Paths
Learn Straight from the Experts Who Shape the Modern Web
Your Path to Senior Developer and Beyond
- 200+ In-depth courses
- 18 Learning Paths
- Industry Leading Experts
- Live Interactive Workshops
Table of Contents
Introduction
Section Duration: 43 minutes
Bianca Gandolfo introduces herself and the course, which is the second course in a series on Algorithms & Data Structures.
Bianca gives a synopsis of the interview stages: Resume, Coding Challenge, Recruiter Phone Screen, Technical Phone Screen and then the Onsite Interview. Within each step, Bianca covers what to expect, and the skills required to succeed at each interview stage.
Bianca describes what employers may be looking for in a potential employee, and the most common mistakes in a resume or job application, the coding challenge, the recruiter phone screen, the technical phone screen, and the onsite interview.
Bianca answers student questions about her experience succeeding in interviews, how to answer tough questions such as, "Why should we hire you?", her thoughts on web presence, how to deal with technical interview questions that you don't know the answer to, how to remain authentic when you hit a speed bump while talking through a problem, the importance of learning the fundamentals to succeed in interviews, and more.
After introducing data structures, which are a way of organizing data so that the data can be used efficiently, Bianca emphasizes that learning data structures are also about learning to solve abstract problems. Then Bianca discusses ordered versus hierarchical data structures and the importance of structure data correctly to best access and store data.
Bianca reviews the course agenda and tips on how better master the material.
Data Structures Overview
Section Duration: 51 minutes
Bianca reviews the types of data structures that commonly show up in interview questions, including Stacks, Queues, Linked Lists, Hash Tables, Arrays & Strings.
Bianca discusses stack and queues comparing the two data structures. Then Bianca introduces time complexity, which is the computational complexity that describes the amount of time it takes to run an algorithm.
Bianca introduces the linked list as both a vital data structure to know for interviews and its applications in non-dynamic programming. - [LINK TO BY REFERENCE BY VALUE HERE]
Bianca demonstrates how the linked list is structured and explains how a doubly-linked list may be beneficial over a singly-linked list.
Bianca discusses use cases of linked lists including use in stack/queues, caching, and handling of hash table collisions. Answering a question from a student, Bianca shows what a doubly-linked list would look like in pseudocode.
Bianca prompts students to create art in the form of Stacks, Queues & Linked List data structures from memory.
Bianca reviews the Stacks, Queues & Linked List data structures drawings that students created.
After discussing the benefits and disadvantages of a hash table data structure, Bianca explains how a hash table structured, with notes on its time complexity, and its applications.
Bianca explains the application of a hash table in objects, ES6 Sets, and ES6 Maps. Then Bianca discusses arrays and strings in the context of data structures.
In this exercise, students draw a hash table, array, and string data structures from memory.
Stack Data Structures
Section Duration: 32 minutes
Bianca discusses the implementation and application of the data structures. She brings up the importance of considering both time and space complexity in the code. She then starts the exercises by explaining how to find the prompts, how the constructor() method works, the private variable's constraints within the constructor, and the push(), pop(), and peek() methods, as well as general expectations for the stack class exercise.
Bianca takes questions from students about how best to approach the exercise questions, the overall scope of the course, and more.
After explaining the process of live coding the solutions, Bianca defines the logic behind the push() method in the stack data structure. After defining the logic behind the pop() method, Bianca implements the constructor(), push(), and pop() methods.
Bianca discusses edge cases to consider in the stack data structure. Bianca then revisits an earlier point regarding type checking when pushing to the stack and what to do if pop() is invoked, but the stack is empty.
Bianca reviews the peek() method and then discusses other methods to consider such as a method that retrieves the length of the stack.
Bianca answers questions from students about the challenges with the implementation of the stack data structure and the usage of private variables.
Queue Data Structures
Section Duration: 21 minutes
Bianca reviews the queue exercise prompt, including the constructor(), enqueue(), dequeue(), peek(), and expectations for implementing the Queue class.
Bianca defines the expected outcomes from the methods in the queue data structure and discusses considerations when implementing the code.
Bianca implements the constructor, enqueue(), and dequeue() methods.
Bianca addresses questions about the applications for stacks and queues, as well as the importance of considering space complexity.
Linked List Data Structures
Section Duration: 47 minutes
Bianca explains the linked list exercise prompt, including the constructor(), insert(), remove(), contains(), and expectations for implementing the LinkedList class. Then, Bianca discusses the private variable's usage and constraints.
Bianca defines the expected outcomes from the methods in the linked list data structure and implements the constructor() method.
Bianca illustrates the insert() method for a linked list.
Taking questions from students, Bianca clarifies how the linked list is structured using an interactive diagram and reviews alternative ways that the linked list might be implemented.
Bianca demonstrates the removeTail() method for a linked list.
Taking questions from students, Bianca discusses considerations in the linked list when writing functions outside of the class, expectations for interview questions regarding linked lists, and more.
Bianca implements the isHead(), isTail(), and contains() methods.
Bianca reviews tips and tricks for learning critical concepts about a linked list from the students.
Hash Table Data Structures
Section Duration: 28 minutes
After illustrating the hash table exercise prompt, including the time complexity of insert(), remove(), retrieve(), Bianca talks about the considerations when implementing the hash table class, including collisions and resizing.
Bianca defines the expected outcomes from the methods in the hash table class, then implements the constructor and insert() methods
Bianca demonstrates the retrieve() method in the hash table data structure.
Bianca implements the remove() method in the hash table data structure.
Common Interview Questions
Section Duration: 22 minutes
Bianca discusses resources for studying data structures.
After explaining the additional problems around studying stack and queue data structures, Bianca describes using an array to implement three stacks, codes a getMin() or getMax() in a stack, creating a queue using stack, sorting a stack, and writing a function that returns true if a string of brackets is valid.
Bianca explains the extra problems provided to study linked list data structures including how to approach implementing methods that delete specific nodes and partitioning a linked list around a value, and more.
After reviewing additional problems provided to study hash table, array, and string data structures, Bianca offers several possible hash table exercises.
Course Review
Section Duration: 13 minutes
Bianca discusses the time and space complexity of the data structures covered in the course.
Bianca illustrates common operations performed on the data structures previously discussed that might be asked in an interview situation.
Bianca reviews other aspects to think about when implementing a data structure, including side effects, and optimization vs. readability, and how to ask for more information from an interviewer.
After providing additional resources for continued education, Bianca wraps up the course.
Learn Straight from the Experts Who Shape the Modern Web
- In-depth Courses
- Industry Leading Experts
- Learning Paths
- Live Interactive Workshops