ES6 实现二叉排序树

ES6 实现二叉排序树

定义节点类

class Node { //定义节点类
    constructor(value) {
        this.value = value;
    }
    addParents(node) { //添加父节点
        this.parents = node
    }
    addChildLeft(node) { //添加左子节点
        this.childLeft = node;
    }
    addChildRight(node) { //添加右子节点
        this.childRight = node
    }
}

定义二叉树类

class Tree { //定义二叉树类
    constructor(arr) {
        this.nodeArr = this.createNode(arr); //生成Node节点数组
        this.preArr = [];//先序遍历数组
        this.MinArr = [];//中序遍历数组
        this.postArr = [];//后序遍历数组
        this.root = this.nodeArr[0]; //二叉排序树根节点
    }
}

二叉排序树特性

二叉排序树又称“二叉查找树”、“二叉搜索树”。

二叉排序树：或者是一棵空树，或者是具有下列性质的二叉树：

1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

3. 它的左、右子树也分别为二叉排序树。

4. 在二叉排序树中能快速找到某个节点，期望O(logn)，最坏O(n)。

生成二叉排序树

接收一组数据，默认第一个数据为根节点，然后遍历这组数据；
1.插入节点小于当前节点，插入到当前节点左边，若当前节点左节点为空将插入节点连接到当前节点的左节点，否则递归当前节点的左节点
2.插入节点大于当前节点，插入到当前节点右边，若当前节点右节点为空将插入节点连接到当前节点的右节点，否则递归当前节点的右节点

算法实现

	createNode(arr) { //生成Node节点数组
    let nodeArr = [];
    for (let i = 0; i < arr.length; i++) { //遍历传入数据
        let element = new Node(arr[i]); //生成node节点 
        nodeArr.push(element); //将节点放入节点数组
    }
    return nodeArr; //返回节点数组
}
	createTree() { //开始构建二叉排序树
        //let arr = [18,  16, 5, 12,11]
        for (let i = 1; i < this.nodeArr.length; i++) { //遍历节点数组
            if (this.nodeArr[i].value < this.nodeArr[0].value) { //如果节点小于根节点，将数据插入到左边
                this.createTreeLeft(this.nodeArr[0], this.nodeArr[i])
            } else { //如果节点小于根节点，将数据插入到右边
                this.createTreeRight(this.nodeArr[0], this.nodeArr[i])
            }
        }
    }
    createTreeLeft(nodeParent, node) {
        if (nodeParent.childLeft == null) { //如果左节点为空，直接将节点插入到节点左边   
            nodeParent.addChildLeft(node);
            node.addParents(nodeParent);
            return;
        } else { //如果左节点不为为空，判断节点是否大于父节点，大于插入到右边且 ，小于则插入到左节点 
            if (node.value <= nodeParent.childLeft.value) {
                this.createTreeLeft(nodeParent.childLeft, node)
            } else {
                this.createTreeRight(nodeParent.childLeft, node)
            }
        }
    }

    createTreeRight(nodeParent, node) { //如果右节点为空，直接将节点插入到节点右边   
        if (nodeParent.childRight == null) {
            nodeParent.addChildRight(node);
            node.addParents(nodeParent);
            return;
        } else { //如果右节点不为为空，判断节点是否小于父节点，小于插入到左节点，大于于则插入到右节点 
            if (node.value > nodeParent.childRight.value) {
                this.createTreeRight(nodeParent.childRight, node)
            } else {
                this.createTreeLeft(nodeParent.childRight, node)
            }
        }
    }

遍历方式

1 先序遍历
先访问根节点，然后依次访问左节点和右节点；

    preOrder(node) { //先序遍历
        if (node != null) {
            this.preArr.push(node)
            this.preOrder(node.childLeft);
            this.preOrder(node.childRight);
        }
    }

1 中序遍历
先访问左节点，然后依次访问根节点和右节点，中序遍历的结果为从小到大的排序结果

    MidOrder(node) { //中序遍历  
        if (node != null) {
            this.MidOrder(node.childLeft);
            this.MinArr.push(node)
            this.MidOrder(node.childRight);
        }
    }

1 后序遍历
先访问左节点，然后依次访问右节点和根节点

    PostOrder(node) { //后序遍历
        if (node != null) {
            this.PostOrder(node.childLeft);
            this.PostOrder(node.childRight);
            this.postArr.push(node)
        }
    }

二叉排序树的查找方式

1.若b是空树，则搜索失败，否则：
2.若x等于b的根节点的数据域之值，则查找成功；否则：
3.若x小于b的根节点的数据域之值，则搜索左子树；否则：
4.查找右子树。
算法实现

findNode(value, node) { //查找节点
        if (node != null) {
            if (value == node.value) {
                return node
            } else if (value < node.value) { //小于遍历左边
                return this.findNode(value, node.childLeft);
            } else { //大于遍历右边
                return this.findNode(value, node.childRight)
            }
        } else {
            return false
        }
    }

增加节点

遍历二叉树将新生成的节点插入到指点位置

addNode(value) { //增加节点
        let node = new Node(value)
        this.nodeArr.push(node)
        if (node.value < this.nodeArr[0].value) { //如果节点小于根节点，将数据插入到左边
            this.createTreeLeft(this.nodeArr[0], node)
        } else { //如果节点小于根节点，将数据插入到右边
            this.createTreeRight(this.nodeArr[0], node)
        }
    }

删除节点

先找到要删除的节点，然后根据情况修改节点信息
1. 该节点没有子节点
2. 该节点左节点和右节点都存在
3. 该节点只有左节点
4. 该节点只有右节点

    removeNode(value) { //删除节点
        let node = this.nodeArr.find(item => item.value == value); //根据值查找node节点
        if (node != undefined) { //如果存在
            this.nodeArr.splice(this.nodeArr.findIndex(item => item.value === value), 1) //在nodeArr中删除节点
            if (node.childRight == null && node.childLeft == null) { //如果要删除的节点没有左节点和右节点
                if (node == node.parents.childLeft) { //判断该节点是父节点的左节点还是右节点
                    node.parents.childLeft = null //删除该节点
                } else {
                    node.parents.childRight = null //删除该节点
                }
            } else if (node.childRight != null && node.childLeft != null) { //如果该节点左节点右节点都存在
                node.childRight.parents = node.childLeft; //将该节点右节点的父节点变成该节点的左节点
                node.childLeft.childRight = node.childRight //将该节点左节点的右节点变成该节点的右节点
                node.childLeft.parents = node.parents; //将该节点的左节点的父节点变成该节点的父节点
                if (node == node.parents.childLeft) { //判断该节点是父节点的左节点还是右节点
                    node.parents.childLeft = node.childLeft //将该节点的左节点变成该节点父节点的左节点
                } else {
                    node.parents.childRight = node.childLeft; //将该节点的左节点变成该节点父节点的右节点
                }
            } else if (node.childLeft == null) { //如果该节点的左节点为空
                if (node == node.parents.childLeft) { //判断该节点是父节点的左节点还是右节点
                    node.parents.childLeft = node.childRight //将该节点的右节点变成该节点父节点的左节点
                } else {
                    node.parents.childRight = node.childRight; //将该节点的右节点变成该节点父节点的右节点
                }
            } else { //如果该节点的右节点为空
                if (node == node.parents.childLeft) { //判断该节点是父节点的左节点还是右节点
                    node.parents.childLeft = node.childLeft //将该节点的左节点变成该节点父节点的左节点
                } else {
                    node.parents.childRight = node.childLeft; //将该节点的左节点变成该节点父节点的右节点
                }
            }
        }
        this.init() //重新遍历
    }

修改节点

先找到该节点，然后修改对应的值，最后重新生成二叉排序树

    updateNode(oldValue, newValue) { //更新节点
        let node = this.findNode(oldValue, this.root); //获取要更新的节点
        if (node) {
            node.value = newValue; //更新节点的值
            this.updateTree(); //重新生成二叉树
        } else { //找不到返回false
            return false
        }
    }

其他方法

init() {
        this.reset() //重置遍历数组
        this.preOrder(this.nodeArr[0]);
        this.MidOrder(this.nodeArr[0]);
        this.PostOrder(this.nodeArr[0])
    }

    reset() { //重置遍历数组
        this.preArr = [];
        this.MinArr = [];
        this.postArr = [];
    }

    distoryTree() { //删除二叉搜索树
        for (let index = 0; index < this.nodeArr.length; index++) {
            this.nodeArr[index].parents = null
            this.nodeArr[index].childRight = null
            this.nodeArr[index].childLeft = null
        }
    }

    updateTree() { //更新二叉搜索树
        this.distoryTree()
        this.createTree()
        this.init()
    }

GitHub

https://github.com/linqiangchen/web-dataStructure