二叉树创建、遍历、查找--js

二叉树数据结构–js
function TreeNode(x) {
this.val = x;
this.left = null;
this.right = null;
}

   //使用构造函数去创建一个类
   function BinarySearchTree() {
            // 用于创建节点的类
            let Node = function (key) {
                this.key = key
                this.left = null
                this.right = null
            }
            // 根节点
            this.root = null;
            // 插入节点
            this.insert = function (key) {
                let newNode = new Node(key)
                this.root == null ? this.root = newNode : insertNode(this.root, newNode)
            }
            function insertNode(node, newNode) {
                if (newNode.key < node.key) {
                    node.left == null ? (node.left = newNode) : (insertNode(node.left, newNode))
                } else {
                    node.right == null ? (node.right = newNode) : (insertNode(node.right, newNode))
                }
            }
        }

        let tree = new BinarySearchTree()
        console.log(tree);
        tree.insert(11)
        tree.insert(7)
        tree.insert(15)
        tree.insert(5)
        tree.insert(8)
        tree.insert(13)
        tree.insert(16)

树的遍历

中序遍历
顺序(左中右)：先访问当前节点的左子树直到左子树为空，再打印当前值，最后访问当前节点的右子树
作用：用于排序一个数组，从小到大升序排列。

        let array = []
        let inOrderTraverse = function (root) {
            inOrderTraverseNode(root)
        }
        let inOrderTraverseNode = function (node) {
            if (node !== null) {
                inOrderTraverseNode(node.left);
                array.push(node.key);
                inOrderTraverseNode(node.right);
            }
        }
        inOrderTraverse(tree.root)

前序遍历
顺序(中左右)：先访问并打印当前节点的值，然后访问当前节点的左子树，最后访问当前节点的右子树
作用：复制一个已有的二叉树结构，性能是最高的。比重新创造一个新的二叉树的效率高十倍多。

        let startTraverseBinary = function (root) {
            traverseBinary(root)
        }
        let traverseBinary = function (node) {
            if (node !== null) {
                array.push(node.key);
                traverseBinary(node.left)
                traverseBinary(node.right)
            }

        }

后序遍历
顺序(左右中)：先访问当前节点的左子树，然后访问当前节点的右子树，最后访问并打印当前节点值
作用：用于操作系统和文件系统的遍历上。

        this.postOrderTraverse = function (root) {
            postOrderTraverseNode(root);
        }
        let postOrderTraverseNode = function (node) {
            if (node !== null) {
                postOrderTraverseNode(node.left)
                postOrderTraverseNode(node.right)
                array.push(node.key)
            }
        }

查找最小值
其实就是一直遍历，从根节点开始，找当前节点的左孩子，直到某个节点没有左孩子了，那么这个节点就是整个二叉树的最小值了
最大值
同样的，从根节点一直向右找，找当前节点的右孩子，直到找到某个节点他没有右节点的时候，那么这个节点就是整个二叉树的最大值。

        if (node) {
            if (node.left) {
                node = node.left;
                return searchMinBinary(node);

            } else {
                return node.key;

            }

        }
        return null;

查找对应值
从根节点开始，先判断当前节点与给定节点的值是否一样，一样就是这个节点的值。不一样就判断给定的值和当前节点的值的大小，左右节点进行递归查找

        if (node) {
            if (node.key == newNode) {
                return node.key;

            } else if (node.key > newNode) {
                node = node.left;
                return searchBinary(node, newNode);

            } else {
                node = node.right;
                return searchBinary(node, newNode);

            }

        }

二叉树的深度

        function TreeDepth(node) {
            if (node == null) return 0
            let leftDep = TreeDepth(node.left)
            let rightDep = TreeDepth(node.right);
            return Math.max(leftDep, rightDep) + 1
        }