npm package: @miniproject/data-structure-algorithm
Description: A comprehensive TypeScript/JavaScript library providing production-ready implementations of common data structures and algorithms.
Author: GIRISH KOR
Latest version: 0.0.7
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

<div align="center">

[View Documentation](https://dsa-dependency.vercel.app/)

</div>

---

## Introduction

A comprehensive Javascript/TypeScript library providing efficient implementations of data structures and algorithms for competitive programming, education, and software development.

## Features

- Extensive collection of algorithms including backtracking, dynamic programming, graph algorithms, greedy algorithms, mathematical algorithms, searching, sorting, and string algorithms
- Robust data structures such as buffers, graphs, hash maps, heaps, linear structures, sets, sketches, specialized trees, and trees
- Fully typed TypeScript implementations with type safety
- Well-documented with comprehensive examples and usage guides
- Optimized for performance and ease of use

---

## Installation

```bash
npm install @miniproject/data-structure-algorithm
```

## Usage

```javascript
import { /* your imports */ } from '@miniproject/data-structure-algorithm';
```

---

## Algorithms

<details>
<summary>Backtracking</summary>

- **[Combinations](https://dsa-dependency.vercel.app/functions/combinations.html)** - `combinations<T>(arr: T[], k: number): T[][]`
- **[Combination Sum](https://dsa-dependency.vercel.app/functions/combinationSum.html)** - `combinationSum(candidates: number[], target: number): number[][]`
- **[Combination Sum (Unlimited)](https://dsa-dependency.vercel.app/functions/combinationSumUnlimited.html)** - `combinationSumUnlimited(candidates: number[], target: number): number[][]`
- **[Expression Add Operators](https://dsa-dependency.vercel.app/functions/expressionAddOperators.html)** - `expressionAddOperators(num: string, target: number): string[]`
- **[Generate Parentheses](https://dsa-dependency.vercel.app/functions/generateParentheses.html)** - `generateParentheses(n: number): string[]`
- **[Letter Combinations](https://dsa-dependency.vercel.app/functions/letterCombinations.html)** - `letterCombinations(digits: string): string[]`
- **[N-Queens](https://dsa-dependency.vercel.app/functions/nQueens.html)** - `nQueens(n: number): number[][]`
- **[Palindrome Partitions](https://dsa-dependency.vercel.app/functions/palindromePartitions.html)** - `palindromePartitions(s: string): string[][]`
- **[Permutations](https://dsa-dependency.vercel.app/functions/permutations.html)** - `permutations<T>(arr: T[]): T[][]`
- **[Restore IP Addresses](https://dsa-dependency.vercel.app/functions/restoreIpAddresses.html)** - `restoreIpAddresses(s: string): string[]`
- **[Subsets](https://dsa-dependency.vercel.app/functions/subsets.html)** - `subsets<T>(arr: T[]): T[][]`
- **[Subset Sum](https://dsa-dependency.vercel.app/functions/subsetSum.html)** - `subsetSum(arr: number[], target: number): boolean`
- **[Sudoku Solver](https://dsa-dependency.vercel.app/functions/sudokuSolver.html)** - `sudokuSolver(board: string[][]): boolean`
- **[Unique Permutations](https://dsa-dependency.vercel.app/functions/uniquePermutations.html)** - `uniquePermutations<T>(arr: T[]): T[][]`
- **[Word Search](https://dsa-dependency.vercel.app/functions/wordSearch.html)** - `wordSearch(board: string[][], word: string): boolean`

</details>

<details>
<summary>Dynamic Programming</summary>

- **[Coin Change](https://dsa-dependency.vercel.app/functions/coinChange.html)** - `coinChange(coins: number[], amount: number): number`
- **[Fibonacci](https://dsa-dependency.vercel.app/functions/fibonacci.html)** - `fibonacci(n: number): number`
- **[Fibonacci (Memoization)](https://dsa-dependency.vercel.app/functions/fibonacciMemo.html)** - `fibonacciMemo(n: number): number`
- **[Get Coin Change Solution](https://dsa-dependency.vercel.app/functions/getCoinChangeSolution.html)** - `getCoinChangeSolution(coins: number[], amount: number): number[]`
- **[Get Houses to Rob](https://dsa-dependency.vercel.app/functions/getHousesToRob.html)** - `getHousesToRob(nums: number[]): number[]`
- **[Get Knapsack 0/1 Items](https://dsa-dependency.vercel.app/functions/getKnapsack01Items.html)** - `getKnapsack01Items(weights: number[], values: number[], capacity: number): number[]`
- **[Get Longest Increasing Subsequence](https://dsa-dependency.vercel.app/functions/getLongestIncreasingSubsequence.html)** - `getLongestIncreasingSubsequence(arr: number[]): number[]`
- **[Get Matrix Chain Multiplication Order](https://dsa-dependency.vercel.app/functions/getMatrixChainMultOrder.html)** - `getMatrixChainMultOrder(p: number[]): number[]`
- **[Get Max Subarray](https://dsa-dependency.vercel.app/functions/getMaxSubarray.html)** - `getMaxSubarray(arr: number[]): number[]`
- **[Get Min Cost Path](https://dsa-dependency.vercel.app/functions/getMinCostPath.html)** - `getMinCostPath(cost: number[][]): number[][]`
- **[Get Rod Cutting Pieces](https://dsa-dependency.vercel.app/functions/getRodCuttingPieces.html)** - `getRodCuttingPieces(prices: number[]): number[]`
- **[House Robber](https://dsa-dependency.vercel.app/functions/houseRobber.html)** - `houseRobber(nums: number[]): number`
- **[Knapsack 0/1](https://dsa-dependency.vercel.app/functions/knapsack01.html)** - `knapsack01(weights: number[], values: number[], capacity: number): number`
- **[Longest Increasing Subsequence](https://dsa-dependency.vercel.app/functions/longestIncreasingSubsequence.html)** - `longestIncreasingSubsequence(arr: number[]): number`
- **[Matrix Chain Multiplication](https://dsa-dependency.vercel.app/functions/matrixChainMultiplication.html)** - `matrixChainMultiplication(p: number[]): number`
- **[Max Subarray Sum](https://dsa-dependency.vercel.app/functions/maxSubarraySum.html)** - `maxSubarraySum(arr: number[]): number`
- **[Min Cost Path](https://dsa-dependency.vercel.app/functions/minCostPath.html)** - `minCostPath(cost: number[][]): number`
- **[Minimum Steps to One](https://dsa-dependency.vercel.app/functions/minimumStepsToOne.html)** - `minimumStepsToOne(n: number): number`
- **[Perfect Squares](https://dsa-dependency.vercel.app/functions/perfectSquares.html)** - `perfectSquares(n: number): number`
- **[Rod Cutting](https://dsa-dependency.vercel.app/functions/rodCutting.html)** - `rodCutting(prices: number[]): number`
- **[Unique Paths](https://dsa-dependency.vercel.app/functions/uniquePaths.html)** - `uniquePaths(m: number, n: number): number`

</details>

<details>
<summary>Graph Algorithms</summary>

- **[Bellman Ford](https://dsa-dependency.vercel.app/functions/bellmanFord.html)** - `bellmanFord(n: number, edges: Array<[number, number, number]>, start: number): number[] | null`
- **[Bipartite Matching](https://dsa-dependency.vercel.app/functions/bipartiteMatching.html)** - `bipartiteMatching(n: number, edges: Array<[number, number]>): number`
- **[Find Articulation Points](https://dsa-dependency.vercel.app/functions/findArticulationPoints.html)** - `findArticulationPoints(n: number, edges: Array<[number, number]>): number[]`
- **[Find Bridges](https://dsa-dependency.vercel.app/functions/findBridges.html)** - `findBridges(n: number, edges: Array<[number, number]>): Array<[number, number]>`
- **[Floyd Warshall](https://dsa-dependency.vercel.app/functions/floydWarshall.html)** - `floydWarshall(graph: number[][]): number[][]`
- **[Hamiltonian Path](https://dsa-dependency.vercel.app/functions/hamiltonianPath.html)** - `hamiltonianPath(n: number, edges: Array<[number, number]>): number[] | null`
- **[Has Cycle (Directed Graph)](https://dsa-dependency.vercel.app/functions/hasCycleDirGraph.html)** - `hasCycleDirGraph(n: number, edges: Array<[number, number]>): boolean`
- **[Has Cycle (Undirected Graph)](https://dsa-dependency.vercel.app/functions/hasCycleUndirGraph.html)** - `hasCycleUndirGraph(n: number, edges: Array<[number, number]>): boolean`
- **[Is Eulerian](https://dsa-dependency.vercel.app/functions/isEulerian.html)** - `isEulerian(n: number, edges: Array<[number, number]>): boolean`
- **[Kruskal's Algorithm](https://dsa-dependency.vercel.app/functions/kruskal.html)** - `kruskal(n: number, edges: Array<[number, number, number]>): number`
- **[Maximum Flow](https://dsa-dependency.vercel.app/functions/maximumFlow.html)** - `maximumFlow(n: number, source: number, sink: number, edges: Array<[number, number, number]>): number`
- **[Prim's Algorithm](https://dsa-dependency.vercel.app/functions/prim.html)** - `prim(n: number, edges: Array<[number, number, number]>): number`
- **[Strongly Connected Components](https://dsa-dependency.vercel.app/functions/stronglyConnectedComponents.html)** - `stronglyConnectedComponents(n: number, edges: Array<[number, number]>): number[][]`
- **[Topological Sort](https://dsa-dependency.vercel.app/functions/topologicalSort.html)** - `topologicalSort(n: number, edges: Array<[number, number]>): number[]`
- **[Weakly Connected Components](https://dsa-dependency.vercel.app/functions/weaklyConnectedComponents.html)** - `weaklyConnectedComponents(n: number, edges: Array<[number, number]>): number`

</details>

<details>
<summary>Greedy Algorithms</summary>

- **[Activity Selection](https://dsa-dependency.vercel.app/functions/activitySelection.html)** - `activitySelection(activities: Array<[number, number]>): Array<[number, number]>`
- **[Coin Change (Greedy)](https://dsa-dependency.vercel.app/functions/coinChangeGreedy.html)** - `coinChangeGreedy(coins: number[], amount: number): number`
- **[Dijkstra's Algorithm](https://dsa-dependency.vercel.app/functions/dijkstra.html)** - `dijkstra(n: number, edges: Array<[number, number, number]>, start: number): number[]`
- **[Egyptian Fraction](https://dsa-dependency.vercel.app/functions/egyptianFraction.html)** - `egyptianFraction(numerator: number, denominator: number): Array<[number, number]>`
- **[Fractional Knapsack](https://dsa-dependency.vercel.app/functions/fractionalKnapsack.html)** - `fractionalKnapsack(weights: number[], values: number[], capacity: number): number`
- **[Graph Coloring](https://dsa-dependency.vercel.app/functions/graphColoring.html)** - `graphColoring(n: number, edges: Array<[number, number]>, colors: number): number[] | null`
- **[Huffman Coding](https://dsa-dependency.vercel.app/functions/huffmanCoding.html)** - `huffmanCoding(frequencies: Map<string, number>): Map<string, string>`
- **[Huffman Decode](https://dsa-dependency.vercel.app/functions/huffmanDecode.html)** - `huffmanDecode(encoded: string, huffmanTree: any): string`
- **[Interval Scheduling](https://dsa-dependency.vercel.app/functions/intervalScheduling.html)** - `intervalScheduling(intervals: Array<[number, number]>): Array<[number, number]>`
- **[Kruskal with Weights](https://dsa-dependency.vercel.app/functions/kruskalWithWeights.html)** - `kruskalWithWeights(n: number, edges: Array<[number, number, number]>): number`
- **[Minimum Platforms](https://dsa-dependency.vercel.app/functions/minimumPlatforms.html)** - `minimumPlatforms(arrivals: number[], departures: number[]): number`
- **[Prim with Weights](https://dsa-dependency.vercel.app/functions/primWithWeights.html)** - `primWithWeights(n: number, edges: Array<[number, number, number]>): number`
- **[Task Scheduling](https://dsa-dependency.vercel.app/functions/taskScheduling.html)** - `taskScheduling(tasks: Array<[string, string[], number]>): string[]`
- **[Weighted Job Scheduling](https://dsa-dependency.vercel.app/functions/weightedJobScheduling.html)** - `weightedJobScheduling(jobs: Array<[number, number, number]>): number`

</details>

<details>
<summary>Mathematical Algorithms</summary>

- **[All Divisors](https://dsa-dependency.vercel.app/functions/allDivisors.html)** - `allDivisors(n: number): number[]`
- **[Bell Numbers](https://dsa-dependency.vercel.app/functions/bell.html)** - `bell(n: number): number`
- **[Catalan Numbers](https://dsa-dependency.vercel.app/functions/catalan.html)** - `catalan(n: number): number`
- **[Combination](https://dsa-dependency.vercel.app/functions/combination.html)** - `combination(n: number, r: number): number`
- **[Count Divisors](https://dsa-dependency.vercel.app/functions/countDivisors.html)** - `countDivisors(n: number): number`
- **[Digital Root](https://dsa-dependency.vercel.app/functions/digitalRoot.html)** - `digitalRoot(n: number): number`
- **[Digit Sum](https://dsa-dependency.vercel.app/functions/digitSum.html)** - `digitSum(n: number): number`
- **[Extended GCD](https://dsa-dependency.vercel.app/functions/extendedGcd.html)** - `extendedGcd(a: number, b: number): [number, number, number]`
- **[Factorial](https://dsa-dependency.vercel.app/functions/factorial.html)** - `factorial(n: number): number`
- **[Fibonacci Matrix](https://dsa-dependency.vercel.app/functions/fibonacciMatrix.html)** - `fibonacciMatrix(n: number): number`
- **[GCD](https://dsa-dependency.vercel.app/functions/gcd.html)** - `gcd(a: number, b: number): number`
- **[GCD Multiple](https://dsa-dependency.vercel.app/functions/gcdMultiple.html)** - `gcdMultiple(nums: number[]): number`
- **[Integer Square Root](https://dsa-dependency.vercel.app/functions/intSqrt.html)** - `intSqrt(n: number): number`
- **[Is Abundant Number](https://dsa-dependency.vercel.app/functions/isAbundantNumber.html)** - `isAbundantNumber(n: number): boolean`
- **[Is Armstrong Number](https://dsa-dependency.vercel.app/functions/isArmstrongNumber.html)** - `isArmstrongNumber(n: number): boolean`
- **[Is Deficient Number](https://dsa-dependency.vercel.app/functions/isDeficientNumber.html)** - `isDeficientNumber(n: number): boolean`
- **[Is Miller-Rabin Prime](https://dsa-dependency.vercel.app/functions/isMillerRabinPrime.html)** - `isMillerRabinPrime(n: number, k?: number): boolean`
- **[Is Neon Number](https://dsa-dependency.vercel.app/functions/isNeonNumber.html)** - `isNeonNumber(n: number): boolean`
- **[Is Perfect Number](https://dsa-dependency.vercel.app/functions/isPerfectNumber.html)** - `isPerfectNumber(n: number): boolean`
- **[Is Perfect Square](https://dsa-dependency.vercel.app/functions/isPerfectSquare.html)** - `isPerfectSquare(n: number): boolean`
- **[Is Prime](https://dsa-dependency.vercel.app/functions/isPrime.html)** - `isPrime(n: number): boolean`
- **[LCM](https://dsa-dependency.vercel.app/functions/lcm.html)** - `lcm(a: number, b: number): number`
- **[LCM Multiple](https://dsa-dependency.vercel.app/functions/lcmMultiple.html)** - `lcmMultiple(nums: number[]): number`
- **[Modular Inverse](https://dsa-dependency.vercel.app/functions/modInverse.html)** - `modInverse(a: number, m: number): number`
- **[Modular Exponentiation](https://dsa-dependency.vercel.app/functions/modPow.html)** - `modPow(base: number, exp: number, mod: number): number`
- **[Pascal's Triangle](https://dsa-dependency.vercel.app/functions/pascalTriangle.html)** - `pascalTriangle(n: number): number[][]`
- **[Permutation](https://dsa-dependency.vercel.app/functions/permutation.html)** - `permutation(n: number, r: number): number`
- **[Power](https://dsa-dependency.vercel.app/functions/power.html)** - `power(base: number, exp: number): number`
- **[Prime Factorization](https://dsa-dependency.vercel.app/functions/primeFactorization.html)** - `primeFactorization(n: number): number[]`
- **[Prime Factorization (Map)](https://dsa-dependency.vercel.app/functions/primeFactorizationMap.html)** - `primeFactorizationMap(n: number): Map<number, number>`
- **[Segmented Sieve](https://dsa-dependency.vercel.app/functions/segmentedSieve.html)** - `segmentedSieve(left: number, right: number): number[]`
- **[Sieve of Eratosthenes](https://dsa-dependency.vercel.app/functions/sieveOfEratosthenes.html)** - `sieveOfEratosthenes(n: number): number[]`
- **[Stirling Numbers](https://dsa-dependency.vercel.app/functions/stirling.html)** - `stirling(n: number, k: number): number`
- **[Sum of Divisors](https://dsa-dependency.vercel.app/functions/sumOfDivisors.html)** - `sumOfDivisors(n: number): number`

</details>

<details>
<summary>Searching Algorithms</summary>

- **[Binary Search](https://dsa-dependency.vercel.app/functions/binarySearch.html)** - `binarySearch<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Binary Search (Recursive)](https://dsa-dependency.vercel.app/functions/binarySearchRecursive.html)** - `binarySearchRecursive<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Exponential Search](https://dsa-dependency.vercel.app/functions/exponentialSearch.html)** - `exponentialSearch<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Fibonacci Search](https://dsa-dependency.vercel.app/functions/fibonacciSearch.html)** - `fibonacciSearch<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Find First](https://dsa-dependency.vercel.app/functions/findFirst.html)** - `findFirst<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Find Insert Position](https://dsa-dependency.vercel.app/functions/findInsertPosition.html)** - `findInsertPosition<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Find Last](https://dsa-dependency.vercel.app/functions/findLast.html)** - `findLast<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Interpolation Search](https://dsa-dependency.vercel.app/functions/interpolationSearch.html)** - `interpolationSearch(array: number[], target: number): number`
- **[Jump Search](https://dsa-dependency.vercel.app/functions/jumpSearch.html)** - `jumpSearch<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Linear Search](https://dsa-dependency.vercel.app/functions/linearSearch.html)** - `linearSearch<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Linear Search All](https://dsa-dependency.vercel.app/functions/linearSearchAll.html)** - `linearSearchAll<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number[]`
- **[Sentinel Linear Search](https://dsa-dependency.vercel.app/functions/sentinelLinearSearch.html)** - `sentinelLinearSearch<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`
- **[Ternary Search](https://dsa-dependency.vercel.app/functions/ternarySearch.html)** - `ternarySearch<T>(array: T[], target: T, compareFn?: (a: T, b: T) => number): number`

</details>

<details>
<summary>Sorting Algorithms</summary>

- **[Bubble Sort](https://dsa-dependency.vercel.app/functions/bubbleSort.html)** - `bubbleSort<T>(array: T[], compareFn?: (a: T, b: T) => number): T[]`
- **[Heap Sort](https://dsa-dependency.vercel.app/functions/heapSort.html)** - `heapSort<T>(array: T[], compareFn?: (a: T, b: T) => number): T[]`
- **[Insertion Sort](https://dsa-dependency.vercel.app/functions/insertionSort.html)** - `insertionSort<T>(array: T[], compareFn?: (a: T, b: T) => number): T[]`
- **[Merge Sort](https://dsa-dependency.vercel.app/functions/mergeSort.html)** - `mergeSort<T>(array: T[], compareFn?: (a: T, b: T) => number): T[]`
- **[Quick Sort](https://dsa-dependency.vercel.app/functions/quickSort.html)** - `quickSort<T>(array: T[], compareFn?: (a: T, b: T) => number): T[]`
- **[Selection Sort](https://dsa-dependency.vercel.app/functions/selectionSort.html)** - `selectionSort<T>(array: T[], compareFn?: (a: T, b: T) => number): T[]`

</details>

<details>
<summary>String Algorithms</summary>

- **[Boyer-Moore](https://dsa-dependency.vercel.app/functions/boyerMoore.html)** - `boyerMoore(text: string, pattern: string): number[]`
- **[Count Occurrences](https://dsa-dependency.vercel.app/functions/countOccurrences.html)** - `countOccurrences(text: string, pattern: string): number`
- **[Edit Distance](https://dsa-dependency.vercel.app/functions/editDistance.html)** - `editDistance(s1: string, s2: string): number`
- **[Get All Unique Substrings](https://dsa-dependency.vercel.app/functions/getAllUniqueSubstrings.html)** - `getAllUniqueSubstrings(s: string): string[]`
- **[Get Edit Operations](https://dsa-dependency.vercel.app/functions/getEditOperations.html)** - `getEditOperations(s1: string, s2: string): EditOp[]`
- **[Get Longest Common Subsequence](https://dsa-dependency.vercel.app/functions/getLongestCommonSubsequence.html)** - `getLongestCommonSubsequence(s1: string, s2: string): string`
- **[Has Unique Characters](https://dsa-dependency.vercel.app/functions/hasUniqueCharacters.html)** - `hasUniqueCharacters(s: string): boolean`
- **[Is Palindrome](https://dsa-dependency.vercel.app/functions/isPalindrome.html)** - `isPalindrome(s: string): boolean`
- **[Is Rotation](https://dsa-dependency.vercel.app/functions/isRotation.html)** - `isRotation(s1: string, s2: string): boolean`
- **[KMP Search](https://dsa-dependency.vercel.app/functions/kmpSearch.html)** - `kmpSearch(text: string, pattern: string): number[]`
- **[Longest Common Subsequence](https://dsa-dependency.vercel.app/functions/longestCommonSubsequence.html)** - `longestCommonSubsequence(s1: string, s2: string): number`
- **[Longest Palindrome](https://dsa-dependency.vercel.app/functions/longestPalindrome.html)** - `longestPalindrome(s: string): string`
- **[Longest Palindrome (Expand)](https://dsa-dependency.vercel.app/functions/longestPalindromeExpand.html)** - `longestPalindromeExpand(s: string): string`
- **[Rabin-Karp](https://dsa-dependency.vercel.app/functions/rabinKarp.html)** - `rabinKarp(text: string, pattern: string): number[]`
- **[Reverse Words](https://dsa-dependency.vercel.app/functions/reverseWords.html)** - `reverseWords(s: string): string`

</details>

---

## Data Structures

<details>
<summary>Buffers</summary>

- **[Array Deque](https://dsa-dependency.vercel.app/classes/ArrayDeque.html)** - `new ArrayDeque<T>()` - FIFO/LIFO double-ended queue with array-backed storage
- **[Circular Buffer](https://dsa-dependency.vercel.app/classes/CircularBuffer.html)** - `new CircularBuffer<T>(capacity: number)` - Fixed-size ring buffer for efficient memory usage
- **[Gap Buffer](https://dsa-dependency.vercel.app/classes/GapBuffer.html)** - `new GapBuffer<T>()` - Two-sided buffer optimized for text editing operations

</details>

<details>
<summary>Graphs</summary>

- **[Graph](https://dsa-dependency.vercel.app/classes/Graph.html)** - `new Graph(directed?: boolean)` - Adjacency list-based graph supporting directed/undirected edges

</details>

<details>
<summary>Hash Maps</summary>

- **[Bloom Filter](https://dsa-dependency.vercel.app/classes/BloomFilter.html)** - `new BloomFilter(size: number, hashFunctions?: number)` - Probabilistic data structure for set membership testing
- **[HashMap](https://dsa-dependency.vercel.app/classes/HashMap.html)** - `new HashMap<K, V>(keyHashFn?: (key: K) => number, initialCapacity?: number)` - Hash table with separate chaining collision resolution
- **[LRU Cache](https://dsa-dependency.vercel.app/classes/LRUCache.html)** - `new LRUCache<K, V>(capacity: number)` - Least Recently Used cache with O(1) operations

</details>

<details>
<summary>Hashing Variants</summary>

- **[Cuckoo HashMap](https://dsa-dependency.vercel.app/classes/CuckooHashMap.html)** - `new CuckooHashMap<K, V>()` - Hash map with cuckoo hashing for collision resolution
- **[Robin Hood HashMap](https://dsa-dependency.vercel.app/classes/RobinHoodHashMap.html)** - `new RobinHoodHashMap<K, V>()` - Hash map with Robin Hood hashing for better distribution

</details>

<details>
<summary>Heaps</summary>

- **[Heap](https://dsa-dependency.vercel.app/classes/Heap.html)** - `new Heap<T>(compareFn?: (a: T, b: T) => number, type?: 'min' | 'max')` - Min/max heap implementation

</details>

<details>
<summary>Linear Structures</summary>

- **[ArrayList](https://dsa-dependency.vercel.app/classes/ArrayList.html)** - `new ArrayList<T>()` - Resizable array-based list with dynamic capacity
- **[Deque](https://dsa-dependency.vercel.app/classes/Deque.html)** - `new Deque<T>()` - Double-ended queue (FIFO/LIFO operations from both ends)
- **[Linked List](https://dsa-dependency.vercel.app/classes/LinkedList.html)** - `new LinkedList<T>()` - Singly linked list with sequential access
- **[Priority Queue](https://dsa-dependency.vercel.app/classes/PriorityQueue.html)** - `new PriorityQueue<T>(compareFn?: (a: T, b: T) => number)` - Queue with priority-based ordering
- **[Queue](https://dsa-dependency.vercel.app/classes/Queue.html)** - `new Queue<T>()` - FIFO queue data structure
- **[Stack](https://dsa-dependency.vercel.app/classes/Stack.html)** - `new Stack<T>()` - LIFO stack data structure

</details>

<details>
<summary>Sets</summary>

- **[Disjoint Set (Union-Find)](https://dsa-dependency.vercel.app/classes/DisjointSet.html)** - `new DisjointSet(n: number)` - Data structure for managing disjoint sets with union and find operations

</details>

<details>
<summary>Sketches & Probabilistic</summary>

- **[Count-Min Sketch](https://dsa-dependency.vercel.app/classes/CountMinSketch.html)** - `new CountMinSketch(width: number, depth: number)` - Probabilistic data structure for frequency estimation
- **[Quotient Filter](https://dsa-dependency.vercel.app/classes/QuotientFilter.html)** - `new QuotientFilter(size: number, quotientBits: number)` - Space-efficient hash filter
- **[XOR Filter](https://dsa-dependency.vercel.app/classes/XorFilter.html)** - `new XorFilter()` - Fast and compact filter for set membership

</details>

<details>
<summary>Specialized Trees</summary>

- **[Binary Lifting](https://dsa-dependency.vercel.app/classes/BinaryLifting.html)** - `new BinaryLifting(n: number, edges: Array<[number, number]>)` - LCA and path query optimization
- **[Cartesian Tree](https://dsa-dependency.vercel.app/classes/CartesianTree.html)** - `new CartesianTree(arr: number[])` - Tree with range minimum query capabilities
- **[Square Root Tree](https://dsa-dependency.vercel.app/classes/SqrtTree.html)** - `new SqrtTree(arr: number[])` - Structure for fast range queries

</details>

<details>
<summary>Trees</summary>

- **[AVL Tree](https://dsa-dependency.vercel.app/classes/AVLTree.html)** - `new AVLTree<T>(compareFn?: (a: T, b: T) => number)` - Self-balancing binary search tree with height constraints
- **[Binary Search Tree](https://dsa-dependency.vercel.app/classes/BinarySearchTree.html)** - `new BinarySearchTree<T>(compareFn?: (a: T, b: T) => number)` - Ordered tree for efficient searching
- **[Fenwick Tree (Binary Indexed Tree)](https://dsa-dependency.vercel.app/classes/FenwickTree.html)** - `new FenwickTree(n: number)` - Data structure for prefix sum and range update queries
- **[Red-Black Tree](https://dsa-dependency.vercel.app/classes/RedBlackTree.html)** - `new RedBlackTree<T>(compareFn?: (a: T, b: T) => number)` - Self-balancing binary search tree with color properties
- **[Segment Tree](https://dsa-dependency.vercel.app/classes/SegmentTree.html)** - `new SegmentTree(arr: number[], operation?: 'sum' | 'min' | 'max')` - Tree for range queries and updates
- **[Trie](https://dsa-dependency.vercel.app/classes/Trie.html)** - `new Trie()` - Prefix tree for efficient string searching and storage

</details>

---

## Author

**Girish Kor**

- Website: [girishkor.dev](https://girishkor.dev/)
- NPM: [@miniproject/data-structure-algorithm](https://www.npmjs.com/package/@miniproject/data-structure-algorithm)