dori.linkedlist

A linked list is a linear collection of data elements, in which linear order is not given by their physical placement in memory. Instead, each element points to the next.

Install

``shell
$ npm i dori.linkedlist
`

Usage

$3

`typescript
import { LinkedListNode } from 'dori.linkedlist'

const node1 = new LinkedListNode(1) // {value: 1, next: null}
const node2 = new LinkedListNode(2, node1) // {value: 2, next: node1}
`

$3

`typescript
import { LinkedList } from 'dori.linkedlist'

const list1 = new LinkedList() // empty LinkedList
const list2 = LinkedList.from([1,2,3]) // create from an array, LinkedListNode(1) -> LinkedListNode(2) -> LinkedListNode(3)
`

$3

`typescript
import { LinkedList } from 'dori.linkedlist'

const list = LinkedList.from([1,2,3]) // create from an array, LinkedListNode(1) -> LinkedListNode(2) -> LinkedListNode(3)
list.find(node => node.value === 1) // return LinkedListNode(1)
list.find(node => node.value === 4) // return null
`

$3

`typescript
import { LinkedList, LinkedListNode } from 'dori.linkedlist'

const list = new LinkedList()

list.prepend(1) // LinkedListNode(1)
list.prepend(new LinkedListNode(2)) // LinkedListNode(2) -> LinkedListNode(1)
list.prepend(new LinkedListNode(3)) // LinkedListNode(3) -> LinkedListNode(2) -> LinkedListNode(1)
list.toArray() // [3,2,1]
`

$3

`typescript
import { LinkedList, LinkedListNode } from 'dori.linkedlist'

const list = new LinkedList()

list.append(1) // LinkedListNode(1)
list.append(new LinkedListNode(2)) // LinkedListNode(1) -> LinkedListNode(2)
list.append(new LinkedListNode(3)) // LinkedListNode(1) -> LinkedListNode(2) -> LinkedListNode(3)
list.toArray() // [1, 2, 3]
`

$3

`typescript
import { LinkedList, LinkedListNode } from 'dori.linkedlist'

const list = new LinkedList()

list.append(1) // LinkedListNode(1)
list.append(new LinkedListNode(2)) // LinkedListNode(1) -> LinkedListNode(2)
list.insert(new LinkedListNode(3), 1) // LinkedListNode(1) -> LinkedListNode(3) -> LinkedListNode(2)
list.toArray() // [1, 3, 2]
`

$3

`typescript
import { LinkedList } from 'dori.linkedlist'

const list = LinkedList.from([1,2,3])

list.remove(node => node.value === 2) // return LinkedListNode(2), list becomes into LinkedListNode(1) -> LinkedListNode(3)
list.toArray() // [1,3]
`

$3

`typescript
import { LinkedList } from 'dori.linkedlist'

const list = LinkedList.from([1,2,3])

list.reverse() // LinkedListNode(3) -> LinkedListNode(2) -> LinkedListNode(1)
list.toArray() // [3,2,1]
`

API

`typescript
/**
* node of linked list
*
* @template T - node value type
*/
declare class LinkedListNode {
value: T;
next: LinkedListNode | null;
/**
* @param {T} value - node value
* @param {LinkedListNode | null} next - node next sibling
*/
constructor(value: T, next?: LinkedListNode | null);
}
/**
* linked list
*
* @template T - linked list node value type
*/
declare class LinkedList {
private _head;
private _tail;
private _size;
private _wrapper;
/**
* create LinkedList from array, T = O(n)
*
* @template T
* @param {T[]} values - node value set
* @returns {LinkedList}
*/
static from(values: T[]): LinkedList;
constructor();
/**
* find node, T = O(n)
*
* @param {LinkedListNode) => boolean} compare - find node which matches compare
* @returns {LinkedListNode | null} - return founded node, if node not exist, return null
*/
find(compare: (node: LinkedListNode) => boolean): LinkedListNode | null;
/**
* insert a new node before linked list head node, T = O(1)
*
* @param {T | LinkedListNode} value - LinkedListNode or other type value to prepend
*/
prepend(value: T | LinkedListNode): void;
/**
* insert a new node after linked list tail node, T = O(1)
*
* @param {T | LinkedListNode} value - LinkedListNode or other type value to append
*/
append(value: T | LinkedListNode): void;
/**
* insert a new node before nth node, T = O(n)
*
* @param {number} index - index to insert \
* if index <= 0, value will be inserted before head node \
* if index >= list size, value will be insert after tail node
* @param {T | LinkedListNode} value - LinkedListNode or other type value to insert
*/
insert(index: number, value: T | LinkedListNode): void;
/**
* remove node, T = O(n)
*
* @param {(node: LinkedListNode, index: number) => boolean} compare - node which matches compare will be removed
* @returns {LinkedListNode | null} - return removed node, if node not exist, return null
*/
remove(compare: (node: LinkedListNode, index: number) => boolean): LinkedListNode | null;
/**
* reverse a linked list, T = O(n)
*
* @returns {LinkedList} - linked list after reverse
*/
reverse(): void;
/**
* get head node
*
* @returns {LinkedListNode}
*/
head(): LinkedListNode | null;
/**
* get tail node
*
* @returns {LinkedListNode}
*/
tail(): LinkedListNode | null;
/**
* get list size
*
* @returns {number}
*/
size(): number;
/**
* transform to array, T = O(n)
*
* @returns {T[]}
*/
toArray(): T[];
}
``