adding insert tests

Author: linux-nerd

src/avl-tree/__test__/avl.spec.ts

@@ -0,0 +1,53 @@
+import { AVLTree } from "../avl"
+import { AVLNode } from "../avl-node";
+
+class Int extends AVLNode<number> {
+  constructor(value: number) {
+    super(value)
+  }
+
+  public compareTo(o: AVLNode<number>): number {
+    if (this.getValue() < o.getValue()) {
+      return -1;
+    } else if (this.getValue() > o.getValue()) {
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+}
+
+describe("AVL Tree", () => {
+  describe("Insert operation", () => {
+    const avlTree = new AVLTree<number>();
+
+    it("should have null node", () => {
+      const root = avlTree.getRoot();
+      expect(root).toBe(null);
+    });
+
+    it("should add a node as root node in an empty tree", () => {
+      const isNodeInsterted = avlTree.insert(new Int(5));
+      const root = avlTree.getRoot();
+      expect(isNodeInsterted).toBeTruthy();
+      expect(root.getValue()).toBe(5);
+      expect(root.nodeHeight()).toBe(0);
+    });
+
+    it("should add a left child to the avl tree", () => {
+      const isNodeInsterted = avlTree.insert(new Int(3));
+      const left = avlTree.getRoot().getLeft();
+      expect(isNodeInsterted).toBeTruthy();
+      expect(left.getValue()).toBe(3);
+      expect(avlTree.getRoot().nodeHeight()).toBe(1);
+    });
+
+    it("should add a right child to the avl tree", () => {
+      const isNodeInsterted = avlTree.insert(new Int(9));
+      const right = avlTree.getRoot().getRight();
+      expect(isNodeInsterted).toBeTruthy();
+      expect(right.getValue()).toBe(9);
+      expect(avlTree.getRoot().nodeHeight()).toBe(1);
+    });
+  })
+})

src/avl-tree/avl-node.ts

@@ -4,10 +4,13 @@ export abstract class AVLNode<T> {
   private leftHeight: number;
   private rightHeight: number;
   private value: number;
+  private parent: AVLNode<T>
+
 
   constructor(value: number) {
     this.left = null;
     this.right = null;
+    this.parent = null;
     this.leftHeight = 0;
     this.rightHeight = 0;
     this.value = value;
@@ -21,6 +24,20 @@ export abstract class AVLNode<T> {
     return (this.rightHeight > this.leftHeight) ? this.rightHeight : this.leftHeight;
   }
 
+  public setNodeHeights(): void {
+    if (this.right == null) {
+      this.rightHeight = 0;
+    } else {
+      this.rightHeight = this.right.nodeHeight() + 1;
+    }
+
+    if (this.left == null) {
+      this.leftHeight = 0;
+    } else {
+      this.leftHeight = this.left.nodeHeight() + 1;
+    }
+  }
+
   public abstract compareTo(o: AVLNode<number>): number
 
   /* #region(collapsed) Getter and Setter */
@@ -59,6 +76,14 @@ export abstract class AVLNode<T> {
   public getValue(): number {
     return this.value;
   }
+  public getParent(): AVLNode<T> {
+    return this.parent;
+  }
+
+  public setParent(parent: AVLNode<T>): void {
+    this.parent = parent;
+  }
+
   /* #endregion */
 
 }

src/avl-tree/avl.ts

@@ -9,10 +9,33 @@ export interface IAVLTree<T> {
 export class AVLTree<T> implements IAVLTree<T> {
   constructor(private root: AVLNode<T> = null) { }
 
-  public insert(node: AVLNode<T>): boolean {
-    // TODO: Implement insert
-    return true;
+  public insert(node: AVLNode<T>, root: AVLNode<T> = this.root): boolean {
+    if (root == null) {
+      this.root = node;
+      return true;
+    }
+
+    if (node.compareTo(root) === 0) {
+      return false;
+    } else if (node.compareTo(root) > 0) {
+      if (root.getRight() == null) {
+        root.setRight(node);
+        this.updateNodeAfterInsert(node, root);
+        return true;
+      } else {
+        return this.insert(node, root.getRight());
+      }
+    } else {
+      if (root.getLeft() == null) {
+        root.setLeft(node);
+        this.updateNodeAfterInsert(node, root);
+        return true;
+      } else {
+        return this.insert(node, root.getLeft());
+      }
+    }
   }
+
   public search(node: AVLNode<T>): boolean {
     // TODO: Implement search
     return true;
@@ -22,9 +45,28 @@ export class AVLTree<T> implements IAVLTree<T> {
     return true;
   }
 
-  private detectRotation(node: AVLNode<T>): void { }
-  private leftRotation(node: AVLNode<T>): void { }
-  private rightRotation(node: AVLNode<T>): void { }
-  private leftRightRotation(node: AVLNode<T>): void { }
-  private rightLeftRotation(node: AVLNode<T>): void { }
+  public getRoot(): AVLNode<T> {
+    return this.root;
+  }
+
+  private updateNodeAfterInsert(node: AVLNode<T>, parent: AVLNode<T>): void {
+    node.setParent(parent);
+    node.setNodeHeights();
+    parent.setNodeHeights()
+  }
+  private detectRotation(node: AVLNode<T>): void {
+    // TODO: add logic
+  }
+  private leftRotation(node: AVLNode<T>): void {
+    // TODO: add logic
+  }
+  private rightRotation(node: AVLNode<T>): void {
+    // TODO: add logic
+  }
+  private leftRightRotation(node: AVLNode<T>): void {
+    // TODO: add logic
+  }
+  private rightLeftRotation(node: AVLNode<T>): void {
+    // TODO: add logic
+  }
 }