Refactoring Disjoint-sets using generic types

Author: LyangHiga

data-structures/basics/linkedList.ts

@@ -1,8 +1,8 @@
 import LLNode from "./llNode";
 
-class LinkedList {
-  head: null | LLNode;
-  tail: null | LLNode;
+class LinkedList<T> {
+  head: null | LLNode<T>;
+  tail: null | LLNode<T>;
   length: number;
   constructor() {
     this.head = null;
@@ -11,7 +11,7 @@ class LinkedList {
   }
 
   // add an element at the last position
-  push = (key: string) => {
+  push = (key: T) => {
     const node = new LLNode(key, this);
     if (!this.head) {
       this.head = node;
@@ -67,7 +67,7 @@ class LinkedList {
   };
 
   // add an element in the beginning of the list
-  unshift = (key: string) => {
+  unshift = (key: T) => {
     let node = new LLNode(key, this);
 
     if (!this.head) {
@@ -97,15 +97,15 @@ class LinkedList {
   };
 
   // set the kth element with val
-  set = (k: number, key: string) => {
+  set = (k: number, key: T) => {
     let node = this.get(k);
     if (!node) return false;
     node.key = key;
     return true;
   };
 
   // insert a new node in the kth position
-  insert = (k: number, key: string) => {
+  insert = (k: number, key: T) => {
     if (k < 0 || k > this.length) return false;
     if (k === 0) {
       this.unshift(key);

data-structures/basics/llNode.ts

@@ -1,7 +1,7 @@
 import LinkedList from "./linkedList";
-class LLNode {
-  next: null | LLNode;
-  constructor(public key: string, public list: LinkedList) {
+class LLNode<T> {
+  next: null | LLNode<T>;
+  constructor(public key: T, public list: LinkedList<T>) {
     this.next = null;
   }
 }

data-structures/disjoint-sets/forestNode.ts

@@ -1,7 +1,7 @@
-class ForestNode {
+class ForestNode<T> {
   rank: number;
-  parent: ForestNode;
-  constructor(public key: string) {
+  parent: ForestNode<T>;
+  constructor(public key: T) {
     this.rank = 0;
     this.parent = this;
   }

data-structures/disjoint-sets/forestSet.ts

@@ -1,18 +1,18 @@
 import ForestNode from "./forestNode";
 
-class ForestSet {
+class ForestSet<T> {
   // node key to node
-  pointers: Map<string, ForestNode>;
+  pointers: Map<T, ForestNode<T>>;
   constructor() {
     this.pointers = new Map();
   }
 
-  makeSet = (x: string) => {
-    const node = new ForestNode(x);
+  makeSet = (x: T) => {
+    const node = new ForestNode<T>(x);
     this.pointers.set(x, node);
   };
 
-  findSet = (x: string) => {
+  findSet = (x: T) => {
     if (!this.pointers.get(x)) return null;
     let node = this.pointers.get(x)!;
 
@@ -23,7 +23,7 @@ class ForestSet {
     return node.parent;
   };
 
-  link = (x: ForestNode, y: ForestNode) => {
+  link = (x: ForestNode<T>, y: ForestNode<T>) => {
     // Union by Rank
     if (x.rank > y.rank) {
       y.parent = x;
@@ -33,7 +33,7 @@ class ForestSet {
     }
   };
 
-  union = (x: string, y: string) => {
+  union = (x: T, y: T) => {
     this.link(this.findSet(x)!, this.findSet(y)!);
   };
 }

data-structures/disjoint-sets/listSet.js

@@ -20,9 +20,9 @@ class ListSet {
             return l.head;
         };
         this.union = (x, y) => {
-            if (typeof x === "string" && !this.pointers.get(x))
+            if (!(x instanceof llNode_1.default) && !this.pointers.get(x))
                 return null;
-            if (typeof y === "string" && !this.pointers.get(y))
+            if (!(y instanceof llNode_1.default) && !this.pointers.get(y))
                 return null;
             const xNode = x instanceof llNode_1.default ? x : this.pointers.get(x);
             const yNode = y instanceof llNode_1.default ? y : this.pointers.get(y);

data-structures/disjoint-sets/listSet.ts

@@ -1,33 +1,33 @@
 import LinkedList from "../basics/linkedList";
 import LLNode from "../basics/llNode";
 
-class ListSet {
+class ListSet<T> {
   // leader key to Linked List
-  lists: Map<string, LinkedList>;
+  lists: Map<T, LinkedList<T>>;
   // node key to node
-  pointers: Map<string, LLNode>;
+  pointers: Map<T, LLNode<T>>;
   constructor() {
     this.lists = new Map();
     this.pointers = new Map();
   }
 
-  makeSet = (x: string) => {
-    const list = new LinkedList();
+  makeSet = (x: T) => {
+    const list = new LinkedList<T>();
     const node = list.push(x);
     this.lists.set(x, list);
     this.pointers.set(x, node);
   };
 
-  findSet = (x: string) => {
+  findSet = (x: T) => {
     if (!this.pointers.get(x)) return null;
     const node = this.pointers.get(x);
     const l = node!.list;
     return l.head;
   };
 
-  union = (x: LLNode | string, y: LLNode | string) => {
-    if (typeof x === "string" && !this.pointers.get(x)) return null;
-    if (typeof y === "string" && !this.pointers.get(y)) return null;
+  union = (x: LLNode<T> | T, y: LLNode<T> | T) => {
+    if (!(x instanceof LLNode) && !this.pointers.get(x)) return null;
+    if (!(y instanceof LLNode) && !this.pointers.get(y)) return null;
 
     const xNode = x instanceof LLNode ? x : this.pointers.get(x)!;
     const yNode = y instanceof LLNode ? y : this.pointers.get(y)!;