Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
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
← Prev
Back
Next →
← Prev
Back
Next →