JS数据结构5：二叉树-二叉搜索树

基本概念

二叉树

二叉树中的节点最多只能有两个子节点：
一个是左侧子节点，另一个是右侧子节点。
这个定义有助于我们写出更高效地在树中插入、查找和删除节点的算法
二叉树在计算机科学中的应用非常广泛。

二叉搜索树

二叉搜索树（BST）是二叉树的一种
但是只允许你在左侧节点存储（比父节点）小的值，在右侧节点存储（比父节点）大的值。

二叉搜索树的代码实现

结构

class Node {
    constructor(key) {
        this.key = key; // 存值
        this.left = null;   // 左子结点
        this.right = null;  // 右子结点
    }


}
// 设计比较大小的方法，注意可读性
let Compare = {
    LES_THAN: -1,
    BIG_THAN: 1,
    EQUAL: 0,
};

class BinarySearch {
    constructor() {
        this.root = null;   // 二叉树结构的根结点
    }
    compareFn(a, b) {
        if (a === b) {
            return Compare.EQUAL;
        }
        return a < b ? Compare.LES_THAN : Compare.BIG_THAN;
    }
}

• insert(key)：向树中插入一个新的键。
• search(key)：在树中查找一个键。如果节点存在，则返回true；如果不存在，则返回false。
• inOrderTraverse()：通过中序遍历方式遍历所有节点。
• preOrderTraverse()：通过先序遍历方式遍历所有节点。
• postOrderTraverse()：通过后序遍历方式遍历所有节点。
• min()：返回树中最小的值/键。
• max()：返回树中最大的值/键。
• remove(key)：从树中移除某个键。

insert

insert(key) {
        if (this.root === null) {
            this.root = new Node(key);
        } else {
            this.insertNode(this.root, key);
        }
    }

insertNode(node, key) {
    if (this.compareFn(key, node.key) === Compare.LES_THAN) {
        // 如果插入的值比当前结点小，往左子树走
        if (node.left === null) {
            // 左子树为空，就插入左子树
            node.left = new Node(key);
        } else {
            // 左子树不为空就向下递归判断左右子树
            this.insertNode(node.left, key);
        }
    }
    // 右子树
    else {
        if (node.right === null) {
            node.right = new Node(key);
        } else {
            this.insertNode(node.right, key);
        }
    }
}

Traverse 遍历

中序遍历（左中右）

• 要通过中序遍历的方法遍历一棵树，首先要检查以参数形式传入的节点是否为null（这就是停止递归继续执行的判断条件，即递归算法的基线条件）。
• 然后，递归调用相同的函数来访问左侧子节点。
• 接着对根节点进行一些操作（callback），然后再访问右侧子节点

inOrderTraverse(cb) {
    this.inOrderTraverseNode(this.root, cb);
}
inOrderTraverseNode(node, cb) {
    if (node != null) {
        this.inOrderTraverseNode(node.left, cb);
        cb(node.key);
        this.inOrderTraverseNode(node.right, cb);

    }
}

先序遍历（中左右）

preOrderTraverse(cb) {
    this.preOrderTraverseNode(this.root, cb);
}
preOrderTraverseNode(node, cb) {
    if (node != null) {
        cb(node.key);
        this.preOrderTraverseNode(node.left, cb);
        this.preOrderTraverseNode(node.right, cb);
    }
}

后序遍历（左右中）

postOrderTraverse(cb) {
    this.postOrderTraverseNode(this.root, cb);
}
postOrderTraverseNode(node, cb) {
    if (node != null) {
        this.postOrderTraverseNode(node.left, cb);
        this.postOrderTraverseNode(node.right, cb);
        cb(node.key);
    }
}

最大最小值

    min() {
        let curr = this.minNode(this.root);
    }

    minNode(node) {
        let curr = node;
        while (curr && curr.left) {
            curr = curr.left;
        }
        return curr;
    }

    max() {
        let curr = this.maxNode(this.root);
    }

    maxNode(node) {
        let curr = node;
        if (curr && curr.right) {
            curr = curr.right;
        }
        return curr;
    }

搜索值是否存在

    search(key) {
        return this.searchNode(this.root, key);
    }
    searchNode(node, key) {
        if (node === null) {
            return false;
        }
        if (this.compareFn(key, node.key) === Compare.LES_THAN) {
            return this.searchNode(node.left, key);
        }
        // 右子树
        else if (this.compareFn(key, node.key) === Compare.BIG_THAN) {
            return this.searchNode(node.right, key);
        }
        else {
            return true;
        }
    }

删除树结点

找到需要删除的结点后，要分三种情况

1. 是叶结点
   
2. 有一个子结点
   
3. 有两个子结点：需要把下面最小的结点补充到这个被删除结点的位置
   
   思路：需要记录删除结点后的数

remove(key) {
    return this.removeNode(this.root, key);
}

removeNode(node, key) {
    // 没有了
    if (node === null) {
        return null;
    }
    // 找左子树
    if (this.compareFn(key, node.key) === Compare.LES_THAN) {
        node.left = this.removeNode(node.left, key);
        return node;
    }
    // 找右子树
    else if (this.compareFn(key, node.key) === Compare.BIG_THAN) {
        node.right = this.removeNode(node.right, key);
        return node;
    }
    else {
        // 1. 删除的是个叶结点
        if (!node.left && !node.right) {
            node = null;
            return node;
        }
        // 2. 没有左（右）子结点，但是有右（左）子结点（只有一个孩子结点）
        else if (!node.left && node.right) {
            node = node.right;
            return node;
        }
        else if (node.left && !node.right) {
            node = node.left;
            return node;
        }
        // 3. 被删除的结点有两个孩子结点
        else {
            const minNode = this.minNode(node.right);   // 找到孩子结点中的最小的一个
            // 用这个最小的结点替换掉删除结点
            node.key = minNode.key;
            // 删除找到的最小结点，并将这个结点的左子树重构（返回删除后的结点）
            node.right = this.removeNode(node.right, minNode.key);
            return node;
        }

    }
}

完整代码

class Node {
    constructor(key) {
        this.key = key; // 存值
        this.left = null;   // 左子结点
        this.right = null;  // 右子结点
    }


}
// 设计比较大小的方法，注意可读性
let Compare = {
    LES_THAN: -1,
    BIG_THAN: 1,
    EQUAL: 0,
};

class BinarySearch {
    constructor() {
        this.root = null;   // 二叉树结构的根结点
    }
    compareFn(a, b) {
        if (a === b) {
            return Compare.EQUAL;
        }
        return a < b ? Compare.LES_THAN : Compare.BIG_THAN;
    }

    insert(key) {
        if (this.root === null) {
            this.root = new Node(key);
        } else {
            this.insertNode(this.root, key);
        }
    }

    insertNode(node, key) {
        if (this.compareFn(key, node.key) === Compare.LES_THAN) {
            // 如果插入的值比当前结点小，往左子树走
            if (node.left === null) {
                // 左子树为空，就插入左子树
                node.left = new Node(key);
            } else {
                // 左子树不为空就向下递归判断左右子树
                this.insertNode(node.left, key);
            }
        }
        // 右子树
        else {
            if (node.right === null) {
                node.right = new Node(key);
            } else {
                this.insertNode(node.right, key);
            }
        }
    }

    inOrderTraverse(cb) {
        this.inOrderTraverseNode(this.root, cb);
    }
    inOrderTraverseNode(node, cb) {
        if (node != null) {
            this.inOrderTraverseNode(node.left, cb);
            cb(node.key);
            this.inOrderTraverseNode(node.right, cb);
        }
    }
    // 前序
    preOrderTraverse(cb) {
        this.preOrderTraverseNode(this.root, cb);
    }
    preOrderTraverseNode(node, cb) {
        if (node != null) {
            cb(node.key);
            this.preOrderTraverseNode(node.left, cb);
            this.preOrderTraverseNode(node.right, cb);
        }
    }
    // 后序遍历
    postOrderTraverse(cb) {
        this.postOrderTraverseNode(this.root, cb);
    }
    postOrderTraverseNode(node, cb) {
        if (node != null) {
            this.postOrderTraverseNode(node.left, cb);
            this.postOrderTraverseNode(node.right, cb);
            cb(node.key);
        }
    }

    min() {
        let curr = this.minNode(this.root);
    }

    minNode(node) {
        let curr = node;
        while (curr && curr.left) {
            curr = curr.left;
        }
        return curr;
    }

    max() {
        let curr = this.maxNode(this.root);
    }

    maxNode(node) {
        let curr = node;
        if (curr && curr.right) {
            curr = curr.right;
        }
        return curr;
    }

    search(key) {
        return this.searchNode(this.root, key);
    }

    searchNode(node, key) {
        if (node === null) {
            return false;
        }
        if (this.compareFn(key, node.key) === Compare.LES_THAN) {
            return this.searchNode(node.left, key);
        }
        // 右子树
        else if (this.compareFn(key, node.key) === Compare.BIG_THAN) {
            return this.searchNode(node.right, key);
        }
        else {
            return true;
        }
    }
    remove(key) {
        return this.removeNode(this.root, key);
    }

    removeNode(node, key) {
        // 没有了
        if (node === null) {
            return null;
        }
        // 左子树
        if (this.compareFn(key, node.key) === Compare.LES_THAN) {
            node.left = this.removeNode(node.left, key);
            return node;
        }
        // 右子树
        else if (this.compareFn(key, node.key) === Compare.BIG_THAN) {
            node.right = this.removeNode(node.right, key);
            return node;
        }
        else {
            // 1. 删除的是个叶结点
            if (!node.left && !node.right) {
                node = null;
                return node;
            }
            // 2. 没有左（右）子结点，但是有右（左）子结点（只有一个孩子结点）
            else if (!node.left && node.right) {
                node = node.right;
                return node;
            }
            else if (node.left && !node.right) {
                node = node.left;
                return node;
            }
            // 3. 被删除的结点有两个孩子结点
            else {
                const minNode = this.minNode(node.right);   // 找到孩子结点中的最小的一个
                // 用这个最小的结点替换掉删除结点
                node.key = minNode.key;
                // 删除找到的最小结点，并将这个结点的左子树重构（返回删除后的结点）
                node.right = this.removeNode(node.right, minNode.key);
                return node;
            }
        }
    }
}

let tree = new BinarySearch();
tree.insert(4);
tree.insert(3);
tree.insert(2);
tree.insert(1);
tree.insert(5);
tree.insert(6);

console.log(tree);
// tree.inOrderTraverse(function (key) {
//     console.log(key);
// });
// tree.preOrderTraverse(function (key) {
//     console.log(key);
// });
tree.postOrderTraverse(function (key) {
    console.log(key);
});

console.log(tree.search(10));
console.log(tree.remove(5));