Hands-On Data Structures and Algorithms with JavaScript电子书

Title Page

Copyright and Credits

Hands-On Data Structures and Algorithms with JavaScript

PacktPub.com

Why subscribe?

PacktPub.com

Contributors

About the author

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

Building Stacks for Application State Management

Prerequisites

Terminology

API

Don't we have arrays for this?

Creating a stack

Implementing stack methods

Testing the stack

Using the stack

Use cases

Creating an Angular application

Installing Angular CLI

Creating an app using the CLI

Creating a stack

Creating a custom back button for a web application

Setting up the application and its routing

Detecting application state changes

Laying out the UI

Navigating between states

Final application logic

Building part of a basic JavaScript syntax parser and evaluator

Building a basic web worker

Laying out the UI

Basic web worker communication

Enabling web worker communications

Transforming input to machine-understandable expression

Converting infix to postfix expressions

Evaluating postfix expressions

Summary

Creating Queues for In-Order Executions

Types of queue

Implementing APIs

Creating a queue

A simple queue

Testing the queue

Priority Queue

Testing a priority queue

Use cases for queues

Creating a Node.js application

Starting the Node.js server

Creating a chat endpoint

Implementing logging using priority queues

Comparing performance

Running benchmark tests

Summary

Using Sets and Maps for Faster Applications

Exploring the origin of sets and maps

Analyzing set and map types

How weak is WeakMap?

Memory management

API differences

Sets versus WeakSets

Understanding WeakSets

The API difference

Use cases

Creating an Angular application

Creating custom keyboard shortcuts for your application

Creating an Angular application

Creating states with keymap

Activity tracking and analytics for web applications

Creating the Angular application

Performance comparison

Sets and Arrays

Maps and Objects

Summary

Using Trees for Faster Lookup and Modifications

Creating an Angular application

Creating a typeahead lookup

Creating a trie tree

Implementing the add() method

The friends' example

Implementing the search() method

Retaining remainders at nodes

The final form

Creating a credit card approval predictor

ID3 algorithm

Calculating target entropy

Calculating branch entropy

The final information gain per branch

Coding the ID3 algorithm

Generating training dataset

Generating the decision tree

Predicting outcome of sample inputs

Visualization of the tree and output

Summary

Simplify Complex Applications Using Graphs

Types of graphs

Use cases

Creating a Node.js web server

Creating a reference generator for a job portal

Creating a bidirectional graph

Generating a pseudocode for the shortest path generation

Implementing the shortest path generation

Creating a web server

Running the reference generator

Creating a friend recommendation system for social media

Understanding PageRank algorithm

Understanding Personalized PageRank (PPR) Algorithm

Pseudocode for personalized PageRank

Creating a web server

Implementing Personalized PageRank

Results and analysis

Summary

Exploring Types of Algorithms

Creating a Node.js application

Use cases

Using recursion to serialize data

Pseudocode

Serializing data

Using Dijkstra to determine the shortest path

Pseudo code

Implementing Dijkstra's algorithm

Using BFS to determine relationships

Pseudo code

Implementing BFS

Using dynamic programming to build a financial planner

Pseudo code

Implementing the dynamic programming algorithm

Using a greedy algorithm to build a travel itinerary

Understanding spanning trees

Pseudo code

Implementing a minimum spanning tree using a greedy algorithm

Using branch and bound algorithm to create a custom shopping list

Understanding branch and bound algorithm

Implementing branch and bound algorithm

When not to use brute-force algorithm

Brute-force Fibonacci generator

Recursive Fibonacci generator

Memoized Fibonacci generator

Summary

Sorting and Its Applications

Types of sorting algorithms

Use cases of different sorting algorithms

Creating an Express server

Mocking library books data

Insertionsort API

What is Insertionsort

Pseudo code

Implementing Insertionsort API

Mergesort API

What is Mergesort

Pseudo code

Implementing Mergesort API

Quicksort API

What is Quicksort

Pseudo code

Implementing the Quicksort API

Lomuto Partition Scheme

Hoare Partition Scheme

Performance comparison

Summary

Big O Notation, Space, and Time Complexity

Terminology

Asymptotic Notations

Big-O notation

Omega notation

Theta Notation

Recap

Examples of time complexity

Constant time

Logarithmic time

Linear time

Quadratic time

Polynomial time

Polynomial time complexity classes

Recursion and additive complexity

Space complexity and Auxiliary space

Examples of Space complexity

Constant space

Linear space

Summary

Micro-Optimizations and Memory Management

Best practices

Best practices for HTML

Declaring the correct DOCTYPE

Adding the correct meta-information to the page

Dropping unnecessary attributes

Making your app mobile ready

Loading style sheets in the <head>

Avoiding inline styles

Using semantic markup

Using Accessible Rich Internet Applications (ARIA) attributes

Loading scripts at the end

CSS best practices

Avoiding inline styles

Do not use !important

Arranging styles within a class alphabetically

Defining the media queries in an ascending order

Best practices for JavaScript

Avoiding polluting the global scope

Using 'use strict'

Strict checking (== vs ===)

Using ternary operators and Boolean || or &&

Modularization of code

Avoiding pyramid of doom

Keeping DOM access to a minimum

Validating all data

Do not reinvent the wheel

HTML optimizations

DOM structuring

Prefetching and preloading resources

<link rel=prefetch >

<link rel=preload >

Layout and layering of HTML

The HTML layout

HTML layers

CSS optimizations

Coding practices

Using smaller values for common ENUM

Using shorthand properties

Avoiding complex CSS selectors

Understanding the browser

Avoiding repaint and reflow

Critical rendering path (CRP)

JavaScript optimizations

Truthy/falsy comparisons

Looping optimizations

The conditional function call

Image and font optimizations

Garbage collection in JavaScript

Mark and sweep algorithm

Garbage collection and V8

Avoiding memory leaks

Assigning variables to global scope

Removing DOM elements and references

Closures edge case

Summary

What's next?

Other Books You May Enjoy

Leave a review - let other readers know what you think