open-index/open-npm huggingface dataset:
npm package: @humanwhocodes/binary-heap
Description: A binary heap implementation in JavaScript
Author: Nicholas C. Zakas
Latest version: 2.0.1

# JavaScript Binary Heap Class

by [Nicholas C. Zakas](https://humanwhocodes.com)

If you find this useful, please consider supporting my work with a [donation](https://humanwhocodes.com/donate).

## Overview

A JavaScript implementation of a binary heap. This class uses the conventions of built-in JavaScript collection objects, such as:

1. There is a `[Symbol.iterator]` method so each instance is iterable.
1. The `size` getter property instead of a `length` data property to indicate that the size of the list is dynamically counted rather than stored.
1. Defining a `values()` generator method.
1. Using `includes()` instead of `contains()`.

## Usage

Use CommonJS to get access to the `BinaryHeap` constructor:

```js
const { BinaryHeap } = require("@humanwhocodes/binary-heap");
```

Each instance of `BinaryHeap` has the following properties and methods:

```js
const heap = new BinaryHeap();

// add an item to the end
heap.add("foo");

// get the minimum value without removing
let value = heap.peek();

// get the minimum value and remove
let value = heap.poll();

// get the number of items
let count = heap.size;

// does the value exist in the heap?
let found = heap.includes(5);

// convert to an array using iterators
let array1 = [...heap.values()];
let array2 = [...heap];

// remove all items
heap.clear();
```

By default, the `BinaryHeap` class is a min heap designed to work with numbers. You can change the comparator used to determine ordering by passing a function into the constructor, such as:

```js
// create a max numeric heap
let heap = new BinaryHeap((a, b) => b - a);
```

The comparator function uses the same format as comparator functions for JavaScript arrays, two values are passed in and you must return:

* A negative number if the first value should come before the second
* Zero if the ordering of the two values should remain unchanged
* A positive number if the first value should come after the second

## Note on Code Style

You may find the code style of this module to be overly verbose with a lot of comments. That is intentional, as the primary use of this module is intended to be for educational purposes. There are frequently more concise ways of implementing the details of this class, but the more concise ways are difficult for newcomers who are unfamiliar with linked lists as a concept or JavaScript as a whole.

## Issues and Pull Requests

As this is part of series of tutorials I'm writing, only bug fixes will be accepted. No new functionality will be added to this module.

## License

MIT
npm package: @humanwhocodes/binary-search-tree
Description: A binary search tree implementation in JavaScript
Author: Nicholas C. Zakas
Latest version: 2.0.0

# JavaScript Binary Search Tree Class

by [Nicholas C. Zakas](https://humanwhocodes.com)

If you find this useful, please consider supporting my work with a [donation](https://humanwhocodes.com/donate).

## Overview

A JavaScript implementation of a binary search tree. This class uses the conventions of built-in JavaScript collection objects, such as:

1. There is a `[Symbol.iterator]` method so each instance is iterable.
1. The `size` getter property instead of a `length` data property to indicate that the size of the tree is dynamically counted rather than stored.
1. Defining a `values()` generator method.

Additionally, this implementation follows the JavaScript `Set` interface for adding, detecting, and removing values:

* `add(value)` to add a value into the tree
* `has(value)` to detect if a value is in the tree
* `delete(value)` to remove a value from the tree

## Usage

Use CommonJS to get access to the `BinarySearchTree` constructor:

```js
const { BinarySearchTree } = require("@humanwhocodes/binary-search-tree");
```

Each instance of `BinarySearchTree` has the following properties and methods:

```js
const tree = new BinarySearchTree();

// add an item to the tree
tree.add(2);

// determine if a value is in the tree
let found = tree.has(2);

// get the number of nodes in the tree
let count = tree.size;

// convert to an array using iterators
let array1 = [...tree.values()];
let array2 = [...tree];

// remove a node with the given value
let value = tree.delete(2);

// remove all nodes
tree.clear();
```

## Note on Code Style

You may find the code style of this module to be overly verbose with a lot of comments. That is intentional, as the primary use of this module is intended to be for educational purposes. There are frequently more concise ways of implementing the details of this class, but the more concise ways are difficult for newcomers who are unfamiliar with linked trees as a concept or JavaScript as a whole.

## Issues and Pull Requests

As this is part of series of tutorials I'm writing, only bug fixes will be accepted. No new functionality will be added to this module.

## License

MIT
npm package: @humanwhocodes/bubble-sort
Description: A bubble sort implementation in JavaScript
Author: Nicholas C. Zakas
Latest version: 2.0.0

# Bubble Sort in JavaScript

by [Nicholas C. Zakas](https://humanwhocodes.com)

If you find this useful, please consider supporting my work with a [donation](https://humanwhocodes.com/donate).

## Overview

This is an implementation of the bubble sort algorithm in JavaScript. The function sorts an array in place.

**Note:** You should always use the builtin `sort()` method on arrays in your code because it is already optimized for production use. This implementation should be used for learning purposes only.

## Usage

Use CommonJS to get access to the `bubbleSort()` function:

```js
const { bubbleSort } = require("@humanwhocodes/bubble-sort");

const items = [1, 5, 2];
const result = bubbleSort(items);

console.log(result);        // [1, 2, 5]
```

## Note on Code Style

You may find the code style of this module to be overly verbose with a lot of comments. That is intentional, as the primary use of this module is intended to be for educational purposes. There are frequently more concise ways of implementing the details of this class, but the more concise ways are difficult for newcomers who are unfamiliar with linked lists as a concept or JavaScript as a whole.

## Issues and Pull Requests

As this is part of series of tutorials I'm writing, only bug fixes will be accepted. No new functionality will be added to this module.

## License

MIT
npm package: @humanwhocodes/circular-doubly-linked-list
Description: A circular doubly linked list implementation in JavaScript
Author: Nicholas C. Zakas
Latest version: 2.0.2

# JavaScript Circular Doubly Linked List Class

by [Nicholas C. Zakas](https://humanwhocodes.com)

If you find this useful, please consider supporting my work with a [donation](https://humanwhocodes.com/donate).

## Overview

A JavaScript implementation of a circular doubly linked list. This class uses the conventions of built-in JavaScript collection objects, such as:

1. There is a `[Symbol.iterator]` method so each instance is iterable.
1. The `size` getter property instead of a `length` data property to indicate that the size of the list is dynamically counted rather than stored.
1. Defining a `values()` generator method.
1. Returning `undefined` from `get()` when no such index exists.

## Usage

Use CommonJS to get access to the `CircularDoublyLinkedList` constructor:

```js
const { CircularDoublyLinkedList } = require("@humanwhocodes/circular-doubly-linked-list");
```

Each instance of `CircularDoublyLinkedList` has the following properties and methods:

```js
const list = new CircularDoublyLinkedList();

// add an item to the end
list.add("foo");

// insert an item
list.insertBefore("bar", 0);
list.insertAfter("baz", 1);

// get the value at an index
let value = list.get(0);

// get the number of items
let count = list.size;

// get the index of a value
let index = list.indexOf("foo");

// convert to an array using iterators
let array1 = [...list.values()];
let array2 = [...list];

// create a circular iterator to keep iterating over values
const iterator = list.circularValues();

// convert to an array in reverse order using an iterator
let array3 = [...list.reverse()];

// remove an item at the given index and return the data that was removed
let data = list.remove(0);

// remove all items
list.clear();
```

## Note on Code Style

You may find the code style of this module to be overly verbose with a lot of comments. That is intentional, as the primary use of this module is intended to be for educational purposes. There are frequently more concise ways of implementing the details of this class, but the more concise ways are difficult for newcomers who are unfamiliar with linked lists as a concept or JavaScript as a whole.

## Issues and Pull Requests

As this is part of series of tutorials I'm writing, only bug fixes will be accepted. No new functionality will be added to this module.

## License

MIT
npm package: @humanwhocodes/circular-linked-list
Description: A circular linked list implementation in JavaScript
Author: Nicholas C. Zakas
Latest version: 2.0.0

# JavaScript Circular Linked List Class

by [Nicholas C. Zakas](https://humanwhocodes.com)

If you find this useful, please consider supporting my work with a [donation](https://humanwhocodes.com/donate).

## Overview

A JavaScript implementation of a linked list. This class uses the conventions of built-in JavaScript collection objects, such as:

1. There is a `[Symbol.iterator]` method so each instance is iterable.
1. The `size` getter property instead of a `length` data property to indicate that the size of the list is dynamically counted rather than stored.
1. Defining a `values()` generator method.
1. Returning `undefined` from `get()` when no such index exists.

## Usage

Use CommonJS to get access to the `CircularLinkedList` constructor:

```js
const { CircularLinkedList } = require("@humanwhocodes/circular-linked-list");
```

Each instance of `CircularLinkedList` has the following properties and methods:

```js
const list = new CircularLinkedList();

// add an item to the end
list.add("foo");

// insert an item
list.insertBefore("bar", 0);
list.insertAfter("baz", 1);

// get the value at an index
let value = list.get(0);

// get the number of items
let count = list.size;

// get the index of a value
let index = list.indexOf("foo");

// convert to an array using iterators
let array1 = [...list.values()];
let array2 = [...list];

// create a circular iterator to keep iterating over values
const iterator = list.circularValues();

// remove an item at the given index and return the data that was removed
let data = list.remove(0);

// remove all items
list.clear();
```

## Note on Code Style

You may find the code style of this module to be overly verbose with a lot of comments. That is intentional, as the primary use of this module is intended to be for educational purposes. There are frequently more concise ways of implementing the details of this class, but the more concise ways are difficult for newcomers who are unfamiliar with linked lists as a concept or JavaScript as a whole.

## Issues and Pull Requests

As this is part of series of tutorials I'm writing, only bug fixes will be accepted. No new functionality will be added to this module.

## License

MIT