humanwhocodes/computer-science-in-javascript

Features

• Algorithm Implementations - Provides standalone JavaScript implementations of classic computer science algorithms.
• Computer Science Education - Provides educational implementations of classic computer science algorithms and data structures in JavaScript.
• Data Structure Implementations - Implements foundational data structures like linked lists and binary search trees from scratch.
• Algorithm Demonstrations - Demonstrates common algorithmic patterns such as recursion and tree traversal with working code examples.
• Binary Search Implementations - Implements binary search for efficiently locating values in sorted arrays.
• JavaScript Implementations - Implements binary search on sorted arrays for efficient O(log n) element lookup in JavaScript.
• Doubly Linked Lists - Implements doubly-linked lists with bidirectional traversal using next and previous pointers.
• Algorithm Implementation Practice - Provides practical code implementations of classic sorting, searching, and tree algorithms for study.
• Sorting Algorithms - Implements classic sorting algorithms such as bubble sort and selection sort.
• JavaScript Implementations - Provides a collection of classic computer science algorithms and data structures implemented in JavaScript for learning and reference.
• JavaScript Implementations - Implements fundamental data structures like linked lists, binary search trees, and circular lists in JavaScript.
• Binary Search Trees - Implements binary search trees with insertion, deletion, and search operations maintaining the binary search property.
• Linked Lists - Organize values in a linear sequence where each element points to the next, enabling efficient insertion and removal without reindexing.
• Binary Search Algorithms - Implements binary search and binary search tree operations that repeatedly halve the search space.
• Data Structure Implementations - Implements fundamental data structures including linked lists, binary search trees, and circular lists from scratch.
• Sorting Algorithms - Implements classic sorting algorithms such as bubble sort and selection sort as reusable array manipulation functions.
• Linked Lists - Store a sequence of elements where each node points to the next, enabling efficient insertions and deletions.
• Linked List Manipulation Utilities - Provides linked list, doubly-linked list, and circular linked list implementations with full traversal and mutation operations.
• Node Insertion Techniques - Implements linked list variants with nodes connected by next and previous pointers for constant-time insertions and deletions.
• Singly - Implements a singly-linked list data structure with full traversal and mutation operations.
• Classic Array Sorting Algorithms - Implements classic sorting algorithms such as bubble sort and selection sort for array ordering.
• Bubble Sorts - Implements bubble sort as a standalone sorting algorithm in JavaScript.
• Swap-Based Sorting Algorithms - Implements bubble sort and selection sort, both of which rearrange arrays by repeatedly swapping elements.
• Standard Binary Searches - Implements binary search on sorted arrays for efficient O(log n) element lookup.
• Structure Iterators - Yield each data item in sequence using a generator, making the list usable with loops and spread syntax.
• Collection Iterators - Implement a generator that yields each item in sequence for use with for-of loops and destructuring.
• Generator-Based Iterators - Uses JavaScript generator functions to provide iterable interfaces for linked lists and trees.
• Index-Based Retrievals - Walk the list from the head to find and return the node at a given index.
• Circular Index Removals - Implements index-based node removal for circular doubly linked lists.
• Circular Index Retrievals - Retrieves node data by index from a circular doubly linked list.
• Luhn Algorithm Validators - Provides a Luhn algorithm implementation for validating credit card numbers.
• Base64 Encoding and Decoding - Provides base64 encoding and decoding utilities for binary-to-text data conversion.
• List Traversal Algorithms - Implements sequential traversal of singly-linked lists by following next pointers.
• Circular List Traversals - Traverses circular doubly linked lists with a post-test loop for head detection.
• Reverse Traversals - Implements reverse iteration for doubly-linked and circular linked lists by following previous pointers.
• Circular Tail Insertions - Inserts nodes at the tail of a circular doubly linked list with constant-time pointer updates.
• Tail Insertions - Insert a new node at the end of the list in constant time by using the tracked tail pointer.
• Tail Insertions - Insert a new node at the end of the list by traversing to the last node and linking it.
• Node Removal Techniques - Delete a specified node from a sequence and reconnects its neighbors, handling first and last positions specially.
• Doubly-Linked List Removals - Delete a node at a given index by adjusting the previous and next pointers of surrounding nodes.
• Positional Removals - Find a node at a given index and remove it while updating both next and previous pointers of adjacent nodes.
• Selection Sorts - Provides a standalone implementation of the selection sort algorithm for educational reference.
• Tree Traversal Algorithms - Implements in-order traversal of binary search trees to output values in sorted order.
• In-Order Iterators - Binary search tree values are output in sorted order by recursively visiting left subtree, current node, then right subtree.
• Circular Infinite Iterations - Provides infinite iteration over circular doubly linked list data using generators.
• Circular Value Iterations - Iterates over circular doubly linked list values using JavaScript generator functions.
• Generator-Based Iterators - Make the list usable with for-of loops and destructuring by implementing a values generator.

Star history