typescript-algorithms-and-datastructures/dist/HashTable.js

Useful algorithms and Data structures written in typescript.

(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "./Utils"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    const Utils_1 = require("./Utils");
    class HashTable {
        constructor(capacity, hash) {
            this.capacity = 0;
            this.buckets = [];
            this.equalKey = (value1, value2) => value1 === value2;
            this.equalValue = (value1, value2) => value1 === value2;
            this.capacity = capacity;
            this.hash = hash;
            for (let i = 0; i < this.capacity; i++) {
                this.buckets.push([]);
            }
        }
        clear() {
            for (let i = 0; i < this.capacity; i++) {
                this.buckets.push([]);
            }
        }
        clone() {
            const copy = new HashTable(this.capacity, this.hash);
            copy.putAll(this.elements());
            return copy;
        }
        contains(value) {
            return this.buckets.some(bucket => bucket.some(entry => this.equalValue(entry.value, value)));
        }
        containsKey(key) {
            const bucket = this.getBucket(key);
            if (bucket.length === 0) {
                return false;
            }
            return bucket.some(entry => this.equalKey(entry.key, key));
        }
        containsValue(value) {
            return this.buckets.some(bucket => bucket.some(entry => this.equalValue(entry.value, value)));
        }
        elements() {
            return this.buckets.reduce((pv, cv) => pv.concat(cv), []);
        }
        get(key) {
            const bucket = this.getBucket(key);
            let value = null;
            bucket.some(entry => {
                if (this.equalKey(entry.key, key)) {
                    value = entry.value;
                    return true;
                }
                return false;
            });
            return value;
        }
        put(key, value) {
            const bucket = this.getBucket(key);
            bucket.push({ key: key, value: value });
        }
        putAll(elements) {
            elements.forEach(el => this.put(el.key, el.value));
        }
        remove(key) {
            const bucket = this.getBucket(key);
            const keyIndex = Utils_1.Utils.findIndexBy(bucket, (el) => this.equalKey(el.key, key));
            if (keyIndex === -1) {
                return null;
            }
            else {
                return bucket.splice(keyIndex, 1)[0].value;
            }
        }
        size() {
            return this.buckets.reduce((total, bucket) => total + bucket.length, 0);
        }
        values() {
            return this.elements().map(e => e.value);
        }
        getBucket(key) {
            let index = this.hash(key);
            if (index < 0) {
                index = Math.abs(index);
            }
            return this.buckets[index < this.buckets.length ? index : index % this.buckets.length];
        }
    }
    exports.HashTable = HashTable;
    exports.default = HashTable;
});
//# sourceMappingURL=HashTable.js.map