Convert Figma logo to code with AI

trekhleb logojavascript-algorithms

📝 Algorithms and data structures implemented in JavaScript with explanations and links to further readings

193,908
30,941
193,908
376
View on GitHubView on NPM

Top Related Projects

TheAlgorithms's avatar

JavaScript

33,892

Algorithms and Data Structures implemented in JavaScript for beginners, following best practices.

yangshun's avatar

tech-interview-handbook

131,656

💯 Curated coding interview preparation materials for busy software engineers

donnemartin's avatar

system-design-primer

325,830

Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

kdn251's avatar

interviews

64,644

Everything you need to know to get the job.

jwasham's avatar

coding-interview-university

332,904

A complete computer science study plan to become a software engineer.

yangshun's avatar

front-end-interview-handbook

43,664

🌐 Front End interview preparation materials for busy engineers (updated for 2025)

Quick Overview

The trekhleb/javascript-algorithms repository is a comprehensive collection of JavaScript implementations of various algorithms and data structures. It serves as an educational resource for developers to learn about fundamental computer science concepts and their practical applications in JavaScript.

Pros

  • Extensive coverage of algorithms and data structures
  • Well-documented code with explanations and complexity analysis
  • Includes unit tests for each implementation
  • Regularly maintained and updated

Cons

  • May be overwhelming for beginners due to the large number of algorithms
  • Some implementations might not be optimized for production use
  • Lacks advanced or specialized algorithms in certain domains
  • Limited explanations of theoretical concepts behind the algorithms

Code Examples

  1. Binary Search implementation:
function binarySearch(sortedArray, seekElement) {
  let startIndex = 0;
  let endIndex = sortedArray.length - 1;

  while (startIndex <= endIndex) {
    const middleIndex = startIndex + Math.floor((endIndex - startIndex) / 2);

    if (sortedArray[middleIndex] === seekElement) {
      return middleIndex;
    }

    if (sortedArray[middleIndex] < seekElement) {
      startIndex = middleIndex + 1;
    } else {
      endIndex = middleIndex - 1;
    }
  }

  return -1;
}
  1. Bubble Sort implementation:
function bubbleSort(originalArray) {
  const array = [...originalArray];

  for (let i = 1; i < array.length; i += 1) {
    for (let j = 0; j < array.length - i; j += 1) {
      if (array[j] > array[j + 1]) {
        [array[j], array[j + 1]] = [array[j + 1], array[j]];
      }
    }
  }

  return array;
}
  1. Linked List implementation:
class LinkedListNode {
  constructor(value, next = null) {
    this.value = value;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
  }

  append(value) {
    const newNode = new LinkedListNode(value);

    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }

    return this;
  }
}

Getting Started

To use the algorithms and data structures in your project:

  1. Clone the repository:

    git clone https://github.com/trekhleb/javascript-algorithms.git

  2. Navigate to the desired algorithm or data structure in the src directory.

  3. Copy the implementation into your project or import it directly:

    import { binarySearch } from './path/to/binary-search';

const array = [1, 2, 3, 4, 5];
const result = binarySearch(array, 3);
console.log(result); // Output: 2

  4. Refer to the accompanying README files for usage instructions and complexity analysis.

Competitor Comparisons

TheAlgorithms logo

JavaScript

33,892

Algorithms and Data Structures implemented in JavaScript for beginners, following best practices.

Pros of JavaScript

  • More comprehensive coverage of algorithms and data structures
  • Better organization with categorized folders for different types of algorithms
  • Includes unit tests for most implementations, enhancing reliability

Cons of JavaScript

  • Less detailed explanations and comments in the code
  • Fewer language-specific optimizations compared to javascript-algorithms
  • Some implementations may be less efficient or not follow best practices

Code Comparison

javascript-algorithms (Binary Search):

function binarySearch(sortedArray, seekElement) {
  let startIndex = 0;
  let endIndex = sortedArray.length - 1;
  while (startIndex <= endIndex) {
    const middleIndex = startIndex + Math.floor((endIndex - startIndex) / 2);
    // ... (rest of the implementation)
  }
  return -1;
}

JavaScript (Binary Search):

function binarySearch(arr, x, low = 0, high = arr.length - 1) {
  if (high >= low) {
    const mid = Math.floor((high + low) / 2);
    if (arr[mid] === x) return mid;
    if (arr[mid] > x) return binarySearch(arr, x, low, mid - 1);
    return binarySearch(arr, x, mid + 1, high);
  }
  return -1;
}

The JavaScript implementation uses recursion, while javascript-algorithms uses an iterative approach. The latter provides more detailed comments and explanations within the code.

yangshun logo

tech-interview-handbook

131,656

💯 Curated coding interview preparation materials for busy software engineers

Pros of tech-interview-handbook

  • Broader scope, covering various aspects of tech interviews beyond algorithms
  • Includes non-technical interview preparation and career advice
  • Provides curated lists of resources and study materials

Cons of tech-interview-handbook

  • Less focused on in-depth algorithm implementations
  • May not provide as much hands-on coding practice
  • JavaScript-specific content is more limited

Code Comparison

tech-interview-handbook:

// Example of a coding question from the handbook
function reverseString(str) {
  return str.split('').reverse().join('');
}

javascript-algorithms:

// Example of a more detailed algorithm implementation
export default class Stack {
  constructor() {
    this.items = [];
  }

  push(element) {
    this.items.push(element);
  }
}

The code comparison shows that javascript-algorithms tends to provide more detailed implementations of data structures and algorithms, while tech-interview-handbook focuses on concise examples and explanations of common interview questions.

donnemartin logo

system-design-primer

325,830

Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

Pros of system-design-primer

  • Comprehensive coverage of system design concepts and principles
  • Includes real-world examples and case studies from large-scale systems
  • Provides visual aids and diagrams to illustrate complex concepts

Cons of system-design-primer

  • Focuses primarily on high-level system design, less on implementation details
  • May be overwhelming for beginners due to the breadth of topics covered
  • Less hands-on coding practice compared to javascript-algorithms

Code Comparison

system-design-primer (Python):

class Store(object):
    def __init__(self, id, name):
        self.id = id
        self.name = name

javascript-algorithms (JavaScript):

class BinaryTreeNode {
  constructor(value = null) {
    this.left = null;
    this.right = null;
    this.value = value;
  }
}

The code snippets demonstrate the difference in focus between the two repositories. system-design-primer provides examples of high-level system components, while javascript-algorithms offers implementations of specific data structures and algorithms.

kdn251 logo

interviews

64,644

Everything you need to know to get the job.

Pros of interviews

  • Covers a broader range of topics, including system design and object-oriented design
  • Includes solutions in multiple programming languages (Java, Python, C++, etc.)
  • Provides more comprehensive explanations and resources for each topic

Cons of interviews

  • Less focused on JavaScript-specific implementations
  • Not as frequently updated as javascript-algorithms
  • Repository structure is less organized, making it harder to navigate

Code Comparison

interviews (Java):

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

javascript-algorithms (JavaScript):

export default function reverseLinkedList(linkedList) {
  let currNode = linkedList.head;
  let prevNode = null;
  let nextNode = null;

  while (currNode) {
    nextNode = currNode.next;
    currNode.next = prevNode;
    prevNode = currNode;
    currNode = nextNode;
  }

  linkedList.head = prevNode;

  return linkedList;
}

Both repositories offer valuable resources for algorithm and data structure preparation. interviews provides a more comprehensive coverage of interview topics across multiple languages, while javascript-algorithms focuses specifically on JavaScript implementations with a well-organized structure.

jwasham logo

coding-interview-university

332,904

A complete computer science study plan to become a software engineer.

Pros of coding-interview-university

  • Comprehensive coverage of computer science fundamentals
  • Language-agnostic approach, suitable for various programming languages
  • Includes study plans and learning resources beyond just algorithms

Cons of coding-interview-university

  • Less focused on practical implementation of algorithms
  • May be overwhelming for beginners due to its extensive content
  • Lacks specific code examples for immediate practice

Code Comparison

coding-interview-university doesn't provide direct code examples, while javascript-algorithms offers implementations. For instance, javascript-algorithms includes:

function binarySearch(sortedArray, seekElement) {
  let startIndex = 0;
  let endIndex = sortedArray.length - 1;
  while (startIndex <= endIndex) {
    const middleIndex = startIndex + Math.floor((endIndex - startIndex) / 2);
    // ... (implementation continues)
  }
}

coding-interview-university would typically link to external resources or provide pseudocode explanations instead of direct implementations.

Summary

javascript-algorithms focuses on practical JavaScript implementations of algorithms and data structures, making it ideal for hands-on learners and those specifically interested in JavaScript. coding-interview-university offers a broader, language-agnostic approach to computer science fundamentals and interview preparation, suitable for those seeking a comprehensive understanding across multiple topics. The choice between the two depends on the learner's goals, preferred learning style, and specific language interests.

yangshun logo

front-end-interview-handbook

43,664

🌐 Front End interview preparation materials for busy engineers (updated for 2025)

Pros of Front-end Interview Handbook

  • Focuses specifically on front-end development topics, making it more targeted for web developers
  • Includes a wider range of interview-related content, such as behavioral questions and resume tips
  • Offers content in multiple languages, making it accessible to a broader audience

Cons of Front-end Interview Handbook

  • Less emphasis on in-depth algorithm implementations and explanations
  • May not be as useful for developers looking to improve their general programming skills beyond front-end development

Code Comparison

Front-end Interview Handbook (HTML example):

<button onclick="alert('Hello, World!')">Click me</button>

JavaScript Algorithms (Algorithm example):

function bubbleSort(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }
  return arr;
}

The code comparison highlights the different focus areas of each repository. Front-end Interview Handbook provides examples related to web development, while JavaScript Algorithms offers implementations of various algorithms and data structures.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

JavaScript Algorithms and Data Structures

🇺🇦 UKRAINE IS BEING ATTACKED BY RUSSIAN ARMY. CIVILIANS ARE GETTING KILLED. RESIDENTIAL AREAS ARE GETTING BOMBED.

CI codecov repo size

This repository contains JavaScript based examples of many popular algorithms and data structures.

Each algorithm and data structure has its own separate README with related explanations and links for further reading (including ones to YouTube videos).

Read this in other languages: 简体中文, 繁體中文, 한국어, 日本語, Polski, Français, Español, Português, Русский, Türkçe, Italiano, Bahasa Indonesia, Українська, Arabic, Tiếng Việt, Deutsch, Uzbek, עברית

Data Structures

A data structure is a particular way of organizing and storing data in a computer so that it can be accessed and modified efficiently. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data.

Remember that each data has its own trade-offs. And you need to pay attention more to why you're choosing a certain data structure than to how to implement it.

B - Beginner, A - Advanced

Algorithms

An algorithm is an unambiguous specification of how to solve a class of problems. It is a set of rules that precisely define a sequence of operations.

B - Beginner, A - Advanced

Algorithms by Topic

Algorithms by Paradigm

An algorithmic paradigm is a generic method or approach which underlies the design of a class of algorithms. It is an abstraction higher than the notion of an algorithm, just as an algorithm is an abstraction higher than a computer program.

How to use this repository

Install all dependencies

npm install

Run ESLint

You may want to run it to check code quality.

npm run lint

Run all tests

npm test

Run tests by name

npm test -- 'LinkedList'

Troubleshooting

If linting or testing is failing, try to delete the node_modules folder and re-install npm packages:

rm -rf ./node_modules
npm i

Also, make sure that you're using the correct Node version (>=16). If you're using nvm for Node version management you may run nvm use from the root folder of the project and the correct version will be picked up.

Playground

You may play with data-structures and algorithms in ./src/playground/playground.js file and write tests for it in ./src/playground/__test__/playground.test.js.

Then just, simply run the following command to test if your playground code works as expected:

npm test -- 'playground'

Useful Information

References

Big O Notation

Big O notation is used to classify algorithms according to how their running time or space requirements grow as the input size grows. On the chart below, you may find the most common orders of growth of algorithms specified in Big O notation.

Big O graphs

Source: Big O Cheat Sheet.

Below is the list of some of the most used Big O notations and their performance comparisons against different sizes of the input data.

Big O NotationTypeComputations for 10 elementsComputations for 100 elementsComputations for 1000 elements
O(1)Constant111
O(log N)Logarithmic369
O(N)Linear101001000
O(N log N)n log(n)306009000
O(N^2)Quadratic100100001000000
O(2^N)Exponential10241.26e+291.07e+301
O(N!)Factorial36288009.3e+1574.02e+2567

Data Structure Operations Complexity

Data StructureAccessSearchInsertionDeletionComments
Array1nnn
Stacknn11
Queuenn11
Linked Listnn1n
Hash Table-nnnIn case of perfect hash function costs would be O(1)
Binary Search TreennnnIn case of balanced tree costs would be O(log(n))
B-Treelog(n)log(n)log(n)log(n)
Red-Black Treelog(n)log(n)log(n)log(n)
AVL Treelog(n)log(n)log(n)log(n)
Bloom Filter-11-False positives are possible while searching

Array Sorting Algorithms Complexity

NameBestAverageWorstMemoryStableComments
Bubble sortnn2n21Yes
Insertion sortnn2n21Yes
Selection sortn2n2n21No
Heap sortn log(n)n log(n)n log(n)1No
Merge sortn log(n)n log(n)n log(n)nYes
Quick sortn log(n)n log(n)n2log(n)NoQuicksort is usually done in-place with O(log(n)) stack space
Shell sortn log(n)depends on gap sequencen (log(n))21No
Counting sortn + rn + rn + rn + rYesr - biggest number in array
Radix sortn * kn * kn * kn + kYesk - length of longest key

Project Backers

You may support this project via ❤️️ GitHub or ❤️️ Patreon.

Folks who are backing this project ∑ = 1

Author

@trekhleb

A few more projects and articles about JavaScript and algorithms on trekhleb.dev

NPM DownloadsLast 30 Days