Javascript二叉树的数据结构

Javascript二叉树

结构

• 1、插入
• 2、查询
  先序遍历

中、左、右

中序遍历

左、中、右

后序遍历

左、右、中

3、测试输出结果
4、代码

// 封装二次上搜索树

function BinarySerachTree() {
    function Node(key) {
        this.key = key;
        this.left = null;
        this.right = null;
    }

    // 属性
    this.root = null;

    // 插入方法
    BinarySerachTree.prototype.insert = function (key) {

        // 1、根据key创建节点
        let newNode = new Node(key);

        // 2、判断根节点是否有值
        if (this.root == null) {
            this.root = newNode;
        } else {
            this.insertNode(this.root, newNode)
        }
    }
    // 节点插入位置的判断方法
    BinarySerachTree.prototype.insertNode = function (node, newNode) {

        // 1、向左查找
        if (newNode.key < node.key) {
            if (node.left == null) {
                node.left = newNode;
            } else {
                this.insertNode(node.left, newNode)
            }
        } else {  // 2、向右查找
            if ((node.right == null)) {
                node.right = newNode;
            } else {
                this.insertNode(node.right, newNode)
            }
        }
    }

    // 树的遍历
    // 1、先序遍历
    BinarySerachTree.prototype.preOrderTraversal = function (handle) {
        this.preOrderTraversalNode(this.root, handle);
    }

    // 节点查找中间件函数（方法）
    BinarySerachTree.prototype.preOrderTraversalNode = function (node, handle) {
        if (node != null) {
            // 处理进过的节点
            handle(node.key) 
            
            // 处理经过的左子节点
            this.preOrderTraversalNode(node.left, handle);

            // 处理经过的右节点
            this.preOrderTraversalNode(node.right, handle);
        }
    }

    // 2、中序遍历
    BinarySerachTree.prototype.midOrderTraversal = function (handle) {
        this.midOrderTraversalNode(this.root, handle);
    }

    BinarySerachTree.prototype.midOrderTraversalNode = function (node, handle) {
        if(node != null) {
            this.midOrderTraversalNode(node.left, handle);
            handle(node.key)
            this.midOrderTraversalNode(node.right, handle);
        }
    }

    //  3、后序遍历
    BinarySerachTree.prototype.postOrderTraversal = function (handle) {
        this.postOrderTraversalNode(this.root, handle);
    }

    BinarySerachTree.prototype.postOrderTraversalNode = function(node, handle) {
        if(node != null ) {
            this.postOrderTraversalNode(node.left, handle);
            this.postOrderTraversalNode(node.right, handle)
            handle(node.key)
        }
    }
}

测试输出

let bst = new BinarySerachTree()

bst.insert(11);
bst.insert(7);
bst.insert(15);
bst.insert(5);
bst.insert(3);
bst.insert(9);
bst.insert(8);
bst.insert(10);
bst.insert(13);
bst.insert(12);
bst.insert(14);
bst.insert(20);
bst.insert(18);
bst.insert(25);
bst.insert(6);


// 测试前序遍历
let str_pre = '';
bst.preOrderTraversal(function(key){
    str_pre += key + ', '
})
console.log(str_pre);

// 测试中序遍历
let str_mid = '';
bst.midOrderTraversal( key => {
    str_mid+= key + ', '
})
console.log(str_mid);

// 测试后序遍历
let str_post = '';
bst.postOrderTraversal( key => {
    str_post += key + ', '
})
console.log(str_post);

输入结果

数据结构