Linked Lists | Learning JavaScript Data Structures and Algorithms

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Learning JavaScript Data Structures and Algorithms - Third Edition

By : Loiane Avancini

3.1 (9)

Learning JavaScript Data Structures and Algorithms

3.1 (9)

By: Loiane Avancini

Overview of this book

A data structure is a particular way of organizing data in a computer to utilize resources efficiently. Data structures and algorithms are the base of every solution to any programming problem. With this book, you will learn to write complex and powerful code using the latest ES 2017 features. Learning JavaScript Data Structures and Algorithms begins by covering the basics of JavaScript and introduces you to ECMAScript 2017, before gradually moving on to the most important data structures such as arrays, queues, stacks, and linked lists. You will gain in-depth knowledge of how hash tables and set data structures function as well as how trees and hash maps can be used to search files in an HD or represent a database. This book serves as a route to take you deeper into JavaScript. You’ll also get a greater understanding of why and how graphs, one of the most complex data structures, are largely used in GPS navigation systems in social networks. Toward the end of the book, you’ll discover how all the theories presented in this book can be applied to solve real-world problems while working on your own computer networks and Facebook searches.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

JavaScript – A Quick Overview

JavaScript – A Quick Overview

JavaScript data structure and algorithms

Setting up the environment

JavaScript basics

Debugging and tools

Summary

ECMAScript and TypeScript Overview

ECMAScript and TypeScript Overview

ECMAScript or JavaScript?

ECMAScript 2015+ functionalities

Introducing TypeScript

Summary

Arrays

Arrays

Why should we use arrays?

Creating and initializing arrays

Adding elements

Removing elements

Adding and removing elements from a specific position

Two-dimensional and multi-dimensional arrays

References for JavaScript array methods

The TypedArray class

Arrays in TypeScript

Summary

Stacks

Stacks

Creating a JavaScript data structure and algorithm library

The stack data structure

Creating a JavaScript object-based Stack class

Protecting the internal elements of the data structure

Solving problems using stacks

Summary

Queues and Deques

Queues and Deques

The queue data structure

The deque data structure

Solving problems using queues and deques

Summary

Linked Lists

Linked Lists

The linked list data structure

Doubly linked lists

Circular linked lists

Sorted linked lists

Creating the StackLinkedList class

Summary

Sets

Sets

Structuring a dataset

Creating a Set class

Set operations

ECMAScript 2015 – the Set class

Multisets or bags

Summary

Dictionaries and Hashes

Dictionaries and Hashes

The dictionary data structure

The hash table

The ES2015 Map class

The ES2015 WeakMap and WeakSet classes

Summary

Recursion

Recursion

Understanding recursion

Calculating the factorial of a number

The Fibonacci sequence

Why use recursion? Is it faster?

Summary

Trees

Trees

The tree data structure

Tree terminology

The binary and binary search trees

Tree traversal

Searching for values in a tree

Self-balancing trees

Summary

Binary Heap and Heap Sort

Binary Heap and Heap Sort

The binary heap data structure

The heap sort algorithm

Summary

Graphs

Graphs

Graph terminology

Representing a graph

Creating the Graph class

Graph traversals

Shortest path algorithms

Minimum spanning tree (MST)

Summary

Sorting and Searching Algorithms

Sorting and Searching Algorithms

Sorting algorithms

Searching algorithms

Shuffle algorithms

Summary

Algorithm Designs and Techniques

Algorithm Designs and Techniques

Divide and conquer

Dynamic programming

Greedy algorithms

Backtracking algorithms

Introduction to functional programming

Summary

Algorithm Complexity

Algorithm Complexity

Big O notation

Having fun with algorithms

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

3.1 (9)

5 star

44.4%

4 star

0%

3 star

11.1%

2 star

11.1%

1 star

33.3%

Doubly linked lists

There are different types of linked list. In this section, we are going to cover the doubly linked list. The difference between a doubly linked list and a normal linked list is that in a linked list we make the link from one node to the next one only, while in a doubly linked list, we have a double link: one for the next element and one for the previous element, as shown in the following diagram:

Let's get started with the changes that are needed to implement the DoublyLinkedList class:

class DoublyNode extends Node { // {1}
  constructor(element, next, prev) {
    super(element, next); // {2}
    this.prev = prev; // {3} NEW
  }
}

class DoublyLinkedList extends LinkedList { // {4}
  constructor(equalsFn = defaultEquals) {
    super(equalsFn); // {5}
    this.tail = undefined; // {6} NEW
  }
}

As the DoublyLinkedList class is a special type of LinkedList, we will extend the LinkedList class ({4}). This means the DoublyLinkedList class will inherit (will have access to...

Visually different images

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Learning JavaScript Data Structures and Algorithms

Search

Your notes and bookmarks