Data Structures in JavaScript - Master the Fundamentals

Data Structures in JavaScript - Master the Fundamentals

by Eduonix Learning Solutions
Released October 2020
Publisher(s): Packt Publishing
ISBN: 9781800566576

Watch it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Video description

Understand the complex world of data structures and algorithms with ease by solving interesting problems

About This Video

  • Get to grips with the fundamentals of data structures and algorithms
  • Learn how to solve common computer programs using algorithms
  • Solve challenges such as Minesweeper, Sieve of Eratosthenes, and Morse code

In Detail

Data structures allow you to organize code in the most efficient way to help you perform operations effectively. An algorithm is a step-by-step procedure for solving problems, be it solving a computer problem, writing source code, or innovating new programs. With this course, you’ll learn the concepts of data structures and algorithms using JavaScript.

Starting with an introduction to data structures and algorithms, the course takes you through the concept of arrays, where you’ll solve a minesweeper challenge to understand the importance of an array in data structures. Next, you’ll become familiar with lists and discover how Big O helps in describing the complexity of an algorithm. As you advance, you’ll gain insights into stacks, queues, recursion, and trees by solving challenges such as condense, Josephus, palindrome, and Morse code. Toward the end, you’ll get an overview of hash maps and graphs.

By the end of this course, you’ll have developed a solid understanding of data structures and algorithms essential for building reliable software.

Who this book is for

If you are looking to build a solid foundation in data structures and algorithms to design and develop software, then this is the course for you.

Table of contents

  1. Chapter 1 : Introduction
    1. Course Outline
  2. Chapter 2 : Arrays
    1. Arrays vs Lists
    2. Common Array Iterations
    3. Pairwise Array Comparisons
    4. Array Functions
    5. Searching Arrays
    6. "Is Sorted" Challenge
    7. "Is Sorted" Solution
    8. Two Dimensional (2D) Arrays
    9. Iterating Over Two Dimensional Arrays
    10. Two Dimensional Bounds Checking
    11. The Minesweeper Challenge
    12. The Minesweeper Solution
    13. The Tally Sort Challenge
    14. The Tally Sort Solution
  3. Chapter 3 : Lists
    1. Lists Out of Arrays
    2. Implementing List Push and Grow Functions
    3. Implementing List Remove
    4. Implement List Insert
    5. The List Contains Challenge
    6. The List Contains Solution
    7. List Get and Set
    8. The Concat Challenge
    9. The Concat Solution
  4. Chapter 4 : The Big O Time Space Asymptomatic Analysis
    1. Introduction to Big O
    2. Big O of N-Squared
    3. Timing Big O of One Versus N Versus N-Squared
    4. No Constants- N Big O Notation
    5. The Big O Challenge
    6. The Big O Solution
  5. Chapter 5 : Linked Lists
    1. Linked Lists
    2. Coding Linked Lists
    3. Linked List Manipulation Challenge
    4. Linked List Manipulation Solution
    5. Linked List Class
    6. Get at Index
    7. Remove at Index
    8. Add at Index
    9. Summarizing Arrays vs Linked Lists
    10. Prefer Manipulating Pointers to Copying Data
  6. Chapter 6 : Stacks
    1. Introduction to Stacks
    2. Stack Implementations
    3. Stack Out of Linked List
    4. Stack Out of Array
    5. The Balance Parenthesis Challenge
    6. The Balance Parenthesis Solution
    7. The Paren Bracket Curly Balance Challenge
    8. The Paren Bracket Curly Balance Solution
    9. The Condense Challenge
    10. The Condense Inefficient Solution
    11. The Condense Efficient Solution
  7. Chapter 7 : Queues
    1. Introduction to Queues
    2. Implementing a Queue
    3. The Josephus Challenge
    4. The Josephus Solution
    5. The Sieve of Eratosthenes Challenge
    6. The Sieve of Eratosthenes Solution
    7. Native JavaScript (JS) Arrays Stacks and Queues
  8. Chapter 8 : Recursion
    1. Introduction to Recursion
    2. Recursive Fibonacci
    3. The Palindrome Challenge
    4. Palindrome Hints
    5. The Palindrome Solution
    6. Palindrome Bonus
  9. Chapter 9 : Trees
    1. Introduction to Trees
    2. Iterating Over Trees
    3. The Tree Sum Challenge
    4. The Tree Sum Solution
    5. The Tree Contains Challenge
    6. The Tree Contains Solution
    7. The Tree Size Leaves Challenge
    8. The Tree Size Leaves Solution
    9. The Tree Min Max Height Challenge
    10. The Tree Min Max Height Solution
    11. Binary Search Trees
    12. Binary Search Tree Add
    13. The Binary Search Tree Contains Challenge
    14. The Binary Search Tree Contains Solution
    15. Unbalanced Binary Search Trees
    16. The Morse Code Challenge
    17. The Morse Code Solution
  10. Chapter 10 : Hash maps
    1. Introduction to Hash Maps
    2. Handling Collisions with Linear Probing
    3. Handling Collisions by Chaining Linked Lists
    4. Coding Linked List Collisions
  11. Chapter 11 : Graphs
    1. Introduction to Graphs
    2. Coding a Graph Class
    3. Breadth First and Depth First Traversals

Product information

  • Title: Data Structures in JavaScript - Master the Fundamentals
  • Author(s): Eduonix Learning Solutions
  • Release date: October 2020
  • Publisher(s): Packt Publishing
  • ISBN: 9781800566576