@caelus-dts/linked-list

Overview

The LinkedList class provides a robust implementation of a doubly linked list data structure in TypeScript. It allows dynamic resizing and offers a comprehensive set of methods for managing and manipulating the list's elements. This structure is particularly efficient for scenarios requiring frequent insertions and deletions.

Features

• Doubly Linked: Elements are linked in both directions, enabling efficient traversal in both forward and reverse order.
• Dynamic Resizing: The list grows and shrinks as needed, accommodating varying numbers of elements.
• Type-Safe: Built using TypeScript generics, ensuring type safety and preventing common errors.
• Comprehensive API: Provides a wide range of methods for adding, removing, searching, and accessing elements.
• Iterable: Supports JavaScript's iterable protocol, allowing easy traversal using loops and other iterable methods.

Installation

1) Using npm

npm install @caelus-dts/linked-list

2) Using yarn

yarn add @caelus-dts/linked-list

3) Using pnpm

pnpm add @caelus-dts/linked-list

Usage

import LinkedList from '@caelus-dts/linked-list';

const list = new LinkedList<number>(); // Create a new linked list of numbers

list.push(10, 20, 30); // Add elements to the end
list.unshift(5, 0);    // Add elements to the beginning

console.log(list.first); // Output: 0
console.log(list.last);  // Output: 30

list.remove(2);         // Remove the element at index 2
console.log(list.toArray()); // Output: [0, 5, 20, 30]

list.clear(); // Clear the list


const customCompareList = new LinkedList<string>(null, (a, b) => a.toLowerCase() === b.toLowerCase()); //Case insensitive comparison

customCompareList.push("apple", "Banana", "ORANGE");
console.log(customCompareList.contains("Orange")); // Output: true (because of the custom compare function)


for (const value of list) {
    console.log(value); // Iterate over the list
}

API Documentation

constructor(values?: Iterable<T> | null, compareFunc?: CompareFunc<T>)

Creates a new LinkedList.

• values: Optional initial values to populate the list. Can be any iterable.
• compareFunc: Optional custom comparison function for methods like contains, indexOf, and count. Defaults to strict equality.

  size: number

  Gets the number of elements in the list.

  isEmpty: boolean

  Checks if the list is empty.

  front: ListNode<T> | undefined

  Gets the first node in the list.

  back: ListNode<T> | undefined

  Gets the last node in the list.

  first: T | undefined

  Gets the value of the first element.

  last: T | undefined

  Gets the value of the last element.

  push(...elements: T[]): number

  Adds elements to the end of the list.

  unshift(...elements: T[]): number

  Adds elements to the beginning of the list.

  shift(): T | undefined

  Removes and returns the first element.

  pop(): T | undefined

  Removes and returns the last element.

  toArray(): T[]

  Converts the list to an array.

  clear(): void

  Removes all elements from the list.

  insert(index: number, value: T): number

  Inserts an element at the specified index.

  remove(index: number): boolean

  Removes the element at the specified index.

  get(index: number): T | undefined

  Gets the element at the specified index.

  indexOf(value: T): number

  Finds the first index of a value.

  contains(value: T): boolean

  Checks if the list contains a value.

  count(value: T): number

  Counts the occurrences of a value

Contributing

Contributions are welcome! Please fork the repository and submit a pull request.

License

MIT License