class HashTable{
    private items:{} = {};
    private length:number = 0;
    private loseloseHashCode(key:string):number{
        var hash = 0;
        for(var i=0; i<key.length; i++){
            hash += key.charCodeAt(i);
        }
        return hash % 37;
    }
    put(key:string, value:any){
        var pos = this.loseloseHashCode(key);
        this.items[pos] = value;
    }
    remove(key:string){
        var pos = this.loseloseHashCode(key);
        delete this.items[pos];
    }
    get(key:string){
        var pos = this.loseloseHashCode(key);
        return this.items[pos];
    }
}

interface Node {
    key: number,
    left: any,
    right: any
}

class Tree {
    private root:any = null;
    private getNode(key:number):Node{
        return {
            key,
            left: null,
            right: null
        }
    }
    private inserNode(oldNode:Node, newNode:Node){
        if(oldNode.key > newNode.key){
            if(oldNode.left === null){
                oldNode.left = newNode;
            }else{
                this.inserNode(oldNode.left, newNode);
            }
        }else{
            if(oldNode.right === null){
                oldNode.right = newNode;
            }else{
                this.inserNode(oldNode.right, newNode);
            }
        }
    }
    public insert(key:number){
        var node = this.getNode(key);
        if(!this.root){
            this.root = node;
        }else{
            this.inserNode(this.root, node);
        }
    }
    public search(key:number, searchNode?:Node){
        var node = searchNode || this.root;
        while(node !== null && node.key !== key){
            if(node.key > key){
                node = node.left;
            }else{
                node = node.right;
            }
        }
        if(node === null){
            return false;
        }
        return node;
    }
    public min(_node?:Node){
        var node = _node || this.root;
        if(this.root === null){
            return false;
        }
        while(node.left !== null){
            node = node.left;
        }
        return node.key;
    }
    public max(_node?:Node){
        var node = _node || this.root;
        if(this.root === null){
            return false;
        }
        while(node.right !== null){
            node = node.right;
        }
        return node.key;
    }
    public remove(key:number, removeNode?:Node){
        var node = removeNode || this.root;
        if(node.key > key){
            node.left = this.remove(key, node.left);
        }else if(node.key < key){
            node.right = this.remove(key, node.right);
        }else{
            if( node.left === null && node.right === null){
                node = null;
            }else if(node.left && node.right === null){
                node = node.left;
            }else if(node.right && node.left === null){
                node = node.right;
            }else{
                var minKey = this.min(node.right);
                node.key = minKey;
                node.right = this.remove(minKey, node.right);
            }
        }
        return node
    }
    public inOrderTraverse(_node?:Node){
        if(_node === null){
            return
        }
        var node = _node || this.root;
        this.inOrderTraverse(node.left);
        console.log(node.key)
        this.inOrderTraverse(node.right);
    }
    public preOrderTraverse(_node?:Node){
        if(_node === null){
            return
        }
        var node = _node || this.root;
        console.log(node.key)
        this.preOrderTraverse(node.left);
        this.preOrderTraverse(node.right);
    }
    public postOrderTraverse(_node?:Node){
        if(_node === null){
            return
        }
        var node = _node || this.root;
        this.postOrderTraverse(node.left);
        this.postOrderTraverse(node.right);
        console.log(node.key)
    }
}

var tree = new Tree();
tree.insert(11);
tree.insert(7);
tree.insert(15);
tree.insert(5);
tree.insert(3);
tree.insert(9);
tree.insert(8);
tree.insert(10);
tree.insert(13);
tree.insert(12);
tree.insert(14);
tree.insert(20);
tree.insert(18);
tree.insert(25);
tree.insert(6);
console.log(tree)
console.log(tree.search(6))
console.log(tree.min())
console.log(tree.max())
console.log(tree.inOrderTraverse())
console.log(tree.preOrderTraverse())
console.log(tree.postOrderTraverse())
console.log(tree.remove(15))

// main.js
var worker = new Worker('js/worker.js');
var workerCallback = {};
var timer = +new Date();
workerCallback['ready'] = () => {
    worker.postMessage({
        type: 'start'
    });
    setTimeout(() => {
        worker.terminate();
    }, 300)
}
workerCallback['end'] = (e) => {
    console.log(+new Date() - timer);
}
worker.onmessage = (e) => {
    workerCallback[e.data.type](e);
}
worker.onerror = (e) => {
    console.log(`ERROR:${e.filename}+(e.lineno):e.message`)
}
// 也可以通过事件监听
worker.addEventListener('message', () => {
    workerCallback[e.data.type](e);
})

-----------------
// worker.js
var worker = this;
worker.postMessage({
    type: 'ready'
})
var workerInfo = {};
workerInfo['start'] = function() {
    var a = 1;
    for (var i = 0; i < 1000000000; i++) {
        a += i;
    }
    worker.postMessage({
        type: 'end',
        data: {
            result: a
        }
    });
}
worker.onmessage = function(e) {
    workerInfo[e.data.type](e);
}