feat: add DisjointSet

src/data-structures/disjoint-set/index.spec.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'vitest';
+import { DisjointSet } from './index.js';
+
+describe('DisjointSet', () => {
+  test('initialize', () => {
+    const ds = new DisjointSet(5);
+    for (let i = 0; i < 5; i += 1) {
+      expect(ds.find(i)).toBe(i);
+    }
+  });
+
+  test('union', () => {
+    const ds = new DisjointSet(5);
+    expect(ds.union(0, 1)).toBe(true);
+    expect(ds.connected(0, 1)).toBe(true);
+    expect(ds.connected(1, 0)).toBe(true);
+  });
+
+  test('already connected elements', () => {
+    const ds = new DisjointSet(5);
+    ds.union(0, 1);
+    expect(ds.union(0, 1)).toBe(false);
+  });
+
+  test('multiple unions', () => {
+    const ds = new DisjointSet(5);
+    ds.union(0, 1);
+    ds.union(1, 2);
+    ds.union(3, 4);
+
+    expect(ds.connected(0, 2)).toBe(true);
+    expect(ds.connected(0, 3)).toBe(false);
+    expect(ds.connected(3, 4)).toBe(true);
+
+    ds.union(2, 4);
+    expect(ds.connected(0, 4)).toBe(true);
+  });
+
+  test('unrelated elements', () => {
+    const ds = new DisjointSet(5);
+    ds.union(0, 1);
+    ds.union(2, 3);
+
+    expect(ds.connected(0, 2)).toBe(false);
+    expect(ds.connected(1, 3)).toBe(false);
+    expect(ds.connected(4, 4)).toBe(true);
+  });
+});

src/data-structures/disjoint-set/index.ts

@@ -0,0 +1,40 @@
+export class DisjointSet {
+  #parent;
+
+  #rank;
+
+  constructor(size: number) {
+    this.#parent = Array.from({ length: size }, (_, i) => i);
+    this.#rank = new Uint32Array(size);
+  }
+
+  find(x: number) {
+    if (this.#parent[x] !== x) {
+      this.#parent[x] = this.find(this.#parent[x]);
+    }
+
+    return this.#parent[x];
+  }
+
+  union(a: number, b: number) {
+    const rootA = this.find(a);
+    const rootB = this.find(b);
+
+    if (rootA === rootB) return false;
+
+    if (this.#rank[rootA] < this.#rank[rootB]) {
+      this.#parent[rootA] = rootB;
+    } else if (this.#rank[rootA] > this.#rank[rootB]) {
+      this.#parent[rootB] = rootA;
+    } else {
+      this.#parent[rootB] = rootA;
+      this.#rank[rootA] += 1;
+    }
+
+    return true;
+  }
+
+  connected(a: number, b: number) {
+    return this.find(a) === this.find(b);
+  }
+}

src/shared/abstract-linked-list/abstract-linked-list.ts

@@ -86,8 +86,10 @@ export abstract class AbstractLinkedList<
 
   protected _isMatch(value: T, matcher: T | Predicate<T>) {
     return isFunction(matcher)
-      ? matcher(value)
-      : this._comparator.equal(matcher, value);
+      ? // @ts-ignore
+        matcher(value)
+      : // @ts-ignore
+        this._comparator.equal(matcher, value);
   }
 
   protected _findNodeByIndex(index: number) {