二叉树

class Node {
    constructor(element, parent) {
        this.element = element
        this.parent = parent
        this.left = null
        this.right = null
    }
}

class BST {
    constructor() {
        this.root = null
        this.size = 0
    }
    add(element) {
        if (this.root === null) {
            this.root = new Node(element, null)
            this.size++
            return
        } else {
            //增加的不是跟节点
            let currentNode = this.root
            let compare = 0 //当前比较的结果
            let parent = null //当前父节点
            while (currentNode) {
                compare = element - currentNode.element
                parent = currentNode
                if (compare > 0) {
                    currentNode = currentNode.right
                } else {
                    currentNode = currentNode.left
                }
            }
            let newNode = new Node(element, parent)
            if (compare > 0) {
                parent.right = newNode
            } else {
                parent.left = newNode
            }

        }

    }
    //先序遍历
    preorderTraversal(visitor) {
        if (visitor == null) return
        const traversal = (node) => {
            if (node === null) return
            visitor.visit(node.element)
            traversal(node.left)
            traversal(node.right)
        }
        traversal(this.root)
    }
    //中序遍历
    inorderTraversal(visitor) {
        if (visitor == null) return
        const traversal = (node) => {
            if (node === null) return

            traversal(node.left)
            visitor.visit(node.element)
            traversal(node.right)
        }
        traversal(this.root)
    }
    //后序遍历
    postorderTraversal(visitor) {
        if (visitor == null) return
        const traversal = (node) => {
            if (node === null) return
            traversal(node.left)
            traversal(node.right)
            visitor.visit(node.element)
        }
        traversal(this.root)
    }
    //层序遍历
    leveTraversal(visitor) {
        const traversal = (node) => {
            if (node === null) return
            let tree = []
            tree.push(node)
            while (tree.length) {
                const node = tree.shift()
                visitor.visit(node.element)
                if (node.left) {
                    tree.push(node.left)
                }
                if (node.right) {
                    tree.push(node.right)
                }
            }
        }
        traversal(this.root)
    }
        //二叉树反转
    inverTree(){
        if(this.root == null) return 
        let stack = [this.root]
        let index = 0
        let currentNode = null
        while(currentNode = stack[index++]){
            //遍历的时候交换左右项
            let tmp = currentNode.left
            currentNode.left= currentNode.right
            currentNode.right = tmp
            if(currentNode.left){
                stack.push(currentNode.left)
            }
            if(currentNode.right){
                stack.push(currentNode.right)
            }
        }
    }
}

let bst = new BST()