Merge pull request #2 from gwtw/1_strict

Enable strict null checks

Author: Tyriar

README.md

@@ -5,6 +5,8 @@
 
 A TypeScript implementation of the [AVL tree](http://www.growingwiththeweb.com/data-structures/avl-tree/overview/) data structure.
 
+Note that the primary purpose of this library is education but it should work in a production environment as well. It's certainly not as performant as it could be as it optimises for readability, abstraction and safety over raw performance.
+
 ![](http://www.growingwiththeweb.com/images/data-structures/avl-tree/avl-tree.svg)
 
 ## Features

package.json

@@ -6,6 +6,7 @@
     "build": "tsc",
     "lint": "tslint --project .",
     "test": "nyc mocha lib/test/*.test.js",
+    "test-report": "nyc --reporter html mocha lib/test/*.test.js",
     "watch": "tsc -w",
     "prepublish": "npm run build"
   },
@@ -35,7 +36,7 @@
     "nyc": "^11.4.1",
     "tslint": "^5.9.1",
     "tslint-consistent-codestyle": "^1.13.0",
-    "typescript": "^2.8.3"
+    "typescript": "^3.0.3"
   },
   "files": [
     "lib/**/*.js",

src/avlTree.ts

@@ -5,8 +5,7 @@
  */
 
 import { Node } from './node';
-
-export type CompareFunction<K> = (a: K, b: K) => number;
+import { AvlTree as AvlTreeApi, CompareFunction } from '@tyriar/avl-tree';
 
 /**
  * Represents how balanced a node's left and right children are.
@@ -24,20 +23,19 @@ const enum BalanceState {
   UNBALANCED_LEFT
 }
 
-export class AvlTree<K, V> {
-  protected _root: Node<K, V> = null;
+export class AvlTree<K, V> implements AvlTreeApi<K, V> {
+  protected _root: Node<K, V> | null = null;
   private _size: number = 0;
+  private _compare: CompareFunction<K>;
 
   /**
    * Creates a new AVL Tree.
    * @param _compare An optional custom compare function.
    */
   constructor(
-    private _compare?: CompareFunction<K>
+    compare?: CompareFunction<K>
   ) {
-    if (!_compare) {
-      this._compare = this._defaultCompare;
-    }
+    this._compare = compare ? compare : this._defaultCompare;
   }
 
   /**
@@ -72,7 +70,7 @@ export class AvlTree<K, V> {
    * @param root The root of the tree to insert in.
    * @return The new tree root.
    */
-  private _insert(key: K, value: V, root: Node<K, V>): Node<K, V> {
+  private _insert(key: K, value: V | undefined, root: Node<K, V> | null): Node<K, V> {
     // Perform regular BST insertion
     if (root === null) {
       return new Node(key, value);
@@ -93,23 +91,23 @@ export class AvlTree<K, V> {
     const balanceState = this._getBalanceState(root);
 
     if (balanceState === BalanceState.UNBALANCED_LEFT) {
-      if (this._compare(key, root.left.key) < 0) {
+      if (this._compare(key, (<Node<K, V>>root.left).key) < 0) {
         // Left left case
         root = root.rotateRight();
       } else {
         // Left right case
-        root.left = root.left.rotateLeft();
+        root.left = (<Node<K, V>>root.left).rotateLeft();
         return root.rotateRight();
       }
     }
 
     if (balanceState === BalanceState.UNBALANCED_RIGHT) {
-      if (this._compare(key, root.right.key) > 0) {
+      if (this._compare(key, (<Node<K, V>>root.right).key) > 0) {
         // Right right case
         root = root.rotateLeft();
       } else {
         // Right left case
-        root.right = root.right.rotateRight();
+        root.right = (<Node<K, V>>root.right).rotateRight();
         return root.rotateLeft();
       }
     }
@@ -132,7 +130,7 @@ export class AvlTree<K, V> {
    * @param root The root of the tree to delete from.
    * @return The new tree root.
    */
-  private _delete(key: K, root: Node<K, V>): Node<K, V> {
+  private _delete(key: K, root: Node<K, V> | null): Node<K, V> | null {
     // Perform regular BST deletion
     if (root === null) {
       this._size++;
@@ -155,7 +153,7 @@ export class AvlTree<K, V> {
         root = root.left;
       } else {
         // Node has 2 children, get the in-order successor
-        const inOrderSuccessor = this._minValueNode(root.right);
+        const inOrderSuccessor = this._minValueNode(<Node<K, V>>root.right);
         root.key = inOrderSuccessor.key;
         root.value = inOrderSuccessor.value;
         root.right = this._delete(inOrderSuccessor.key, root.right);
@@ -172,25 +170,25 @@ export class AvlTree<K, V> {
 
     if (balanceState === BalanceState.UNBALANCED_LEFT) {
       // Left left case
-      if (this._getBalanceState(root.left) === BalanceState.BALANCED ||
-          this._getBalanceState(root.left) === BalanceState.SLIGHTLY_UNBALANCED_LEFT) {
+      if (this._getBalanceState((<Node<K, V>>root.left)) === BalanceState.BALANCED ||
+          this._getBalanceState((<Node<K, V>>root.left)) === BalanceState.SLIGHTLY_UNBALANCED_LEFT) {
         return root.rotateRight();
       }
       // Left right case
       // this._getBalanceState(root.left) === BalanceState.SLIGHTLY_UNBALANCED_RIGHT
-      root.left = root.left.rotateLeft();
+      root.left = (<Node<K, V>>root.left).rotateLeft();
       return root.rotateRight();
     }
 
     if (balanceState === BalanceState.UNBALANCED_RIGHT) {
       // Right right case
-      if (this._getBalanceState(root.right) === BalanceState.BALANCED ||
-          this._getBalanceState(root.right) === BalanceState.SLIGHTLY_UNBALANCED_RIGHT) {
+      if (this._getBalanceState((<Node<K, V>>root.right)) === BalanceState.BALANCED ||
+          this._getBalanceState((<Node<K, V>>root.right)) === BalanceState.SLIGHTLY_UNBALANCED_RIGHT) {
         return root.rotateLeft();
       }
       // Right left case
       // this._getBalanceState(root.right) === BalanceState.SLIGHTLY_UNBALANCED_LEFT
-      root.right = root.right.rotateRight();
+      root.right = (<Node<K, V>>root.right).rotateRight();
       return root.rotateLeft();
     }
 
@@ -200,14 +198,20 @@ export class AvlTree<K, V> {
   /**
    * Gets the value of a node within the tree with a specific key.
    * @param key The key being searched for.
-   * @return The value of the node or null if it doesn't exist.
+   * @return The value of the node (which may be undefined), or null if it
+   * doesn't exist.
    */
-  public get(key: K): V {
+  public get(key: K): V | undefined | null {
     if (this._root === null) {
       return null;
     }
 
-    return this._get(key, this._root).value;
+    const result = this._get(key, this._root);
+    if (result === null) {
+      return null;
+    }
+
+    return result.value;
   }
 
   /**
@@ -216,7 +220,7 @@ export class AvlTree<K, V> {
    * @param root The root of the tree to search in.
    * @return The value of the node or null if it doesn't exist.
    */
-  private _get(key: K, root: Node<K, V>): Node<K, V> {
+  private _get(key: K, root: Node<K, V>): Node<K, V> | null {
     const result = this._compare(key, root.key);
     if (result === 0) {
       return root;
@@ -249,16 +253,22 @@ export class AvlTree<K, V> {
   }
 
   /**
-   * @return The minimum key in the tree.
+   * @return The minimum key in the tree or null if there are no nodes.
    */
-  public findMinimum(): K {
+  public findMinimum(): K | null {
+    if (this._root === null) {
+      return null;
+    }
     return this._minValueNode(this._root).key;
   }
 
   /**
-   * Gets the maximum key in the tree.
+   * Gets the maximum key in the tree or null if there are no nodes.
    */
-  public findMaximum(): K {
+  public findMaximum(): K | null {
+    if (this._root === null) {
+      return null;
+    }
     return this._maxValueNode(this._root).key;
   }
 

src/node.ts

@@ -5,9 +5,9 @@
  */
 
 export class Node<K, V> {
-  public left: Node<K, V> = null;
-  public right: Node<K, V> = null;
-  public height: number = null;
+  public left: Node<K, V> | null = null;
+  public right: Node<K, V> | null = null;
+  public height: number | null = null;
 
   /**
    * Creates a new AVL Tree node.
@@ -16,21 +16,22 @@ export class Node<K, V> {
    */
   constructor(
     public key: K,
-    public value: V
+    public value: V | undefined
   ) {
   }
 
   /**
    * Performs a right rotate on this node.
    * @return The root of the sub-tree; the node where this node used to be.
+   * @throws If Node.left is null.
    */
   public rotateRight(): Node<K, V> {
     //     b                           a
     //    / \                         / \
     //   a   e -> b.rotateRight() -> c   b
     //  / \                             / \
     // c   d                           d   e
-    const other = this.left;
+    const other = <Node<K, V>>this.left;
     this.left = other.right;
     other.right = this;
     this.height = Math.max(this.leftHeight, this.rightHeight) + 1;
@@ -41,14 +42,15 @@ export class Node<K, V> {
   /**
    * Performs a left rotate on this node.
    * @return The root of the sub-tree; the node where this node used to be.
+   * @throws If Node.right is null.
    */
   public rotateLeft(): Node<K, V> {
     //   a                              b
     //  / \                            / \
     // c   b   -> a.rotateLeft() ->   a   e
     //    / \                        / \
     //   d   e                      c   d
-    const other = this.right;
+    const other = <Node<K, V>>this.right;
     this.right = other.left;
     other.left = this;
     this.height = Math.max(this.leftHeight, this.rightHeight) + 1;
@@ -62,10 +64,10 @@ export class Node<K, V> {
    * @return The height of the left child, or -1 if it doesn't exist.
    */
   public get leftHeight(): number {
-    if (!this.left) {
+    if (this.left === null) {
       return -1;
     }
-    return this.left.height;
+    return this.left.height || 0;
   }
 
   /**
@@ -74,9 +76,9 @@ export class Node<K, V> {
    * @return The height of the right child, or -1 if it doesn't exist.
    */
   public get rightHeight(): number {
-    if (!this.right) {
+    if (this.right === null) {
       return -1;
     }
-    return this.right.height;
+    return this.right.height || 0;
   }
 }

src/test/custom-compare.test.ts

@@ -12,8 +12,16 @@ describe('Custom compare function', () => {
     assert.equal(tree.findMaximum(), 1);
     tree.delete(3);
     assert.equal(tree.size, 2);
+    if (!tree.root) {
+      assert.fail('tree.root must exist');
+      return;
+    }
     assert.equal(tree.root.key, 2);
     assert.equal(tree.root.left, null);
+    if (!tree.root.right) {
+      assert.fail('tree.root.right must exist');
+      return;
+    }
     assert.equal(tree.root.right.key, 1);
   });