数据结构——二叉搜索树的实现、删除（最大值和最小值、最大值和最小值）

目录

一、二叉搜索树的实现、删除

1、最大值和最小值

2、最大值和最小值

二、二叉搜索树的删除

1、删除节点的思路

2、情况一: 没有子节点

3、情况二: 一个子节点

4、情况三: 两个子节点

5、删除节点完整代码

---

一、二叉搜索树的实现、删除

1、最大值和最小值

2、最大值和最小值

代码如下面实现

二、二叉搜索树的删除

1、删除节点的思路

• 删除节点要从查找要删的节点开始, 找到节点后, 需要考虑三种情况:

  • 该节点是叶结点(没有子节点) 没有子节点的根节点

  • 该节点有一个子节点

  • 该节点有两个子节点.

2、情况一: 没有子节点

- 我们需要检测current的left以及right是否都为null.
- 都为null之后还要检测一个东西, 就是是否current就是根, 都为null, 并且为跟根, 那么相当于要清空二叉树(当然, 只是清空了根, 因为只有它).
- 否则就把父节点的left或者right字段设置为null即可.

3、情况二: 一个子节点

- 要删除的current结点, 只有2个连接(如果有两个子结点, 就是三个连接了), 一个连接父节点, 一个连接唯一的子节点.
- 需要从这三者之间: 爷爷 - 自己 - 儿子, 将自己(current)剪短, 让爷爷直接连接儿子即可.
- 这个过程要求改变父节点的left或者right, 指向要删除节点的子节点.
- 当然, 在这个过程中还要考虑是否current就是根.

4、情况三: 两个子节点

• 如果我们要删除的节点有两个子节点, 甚至子节点还有子节点, 需要从下面的子节点中找到一个节点, 来替换当前的节点.

• 这个节点==> 应该是current节点下面所有节点中最接近current节点的.

  • 要么比current节点小一点点, 要么比current节点大一点点.

  • 总结最接近current, 你就可以用来替换current的位置.

• 这个节点怎么找呢?

  • 比current小一点点的节点, 一定是current左子树的最大值.

  • 比current大一点点的节点, 一定是current右子树的最小值.

• 前驱&后继

  • 而在二叉搜索树中, 这两个特别的节点, 有两个特比的名字.

  • 比current小一点点的节点, 称为current节点的前驱.

  • 比current大一点点的节点, 称为current节点的后继.

• 也就是为了能够删除有两个子节点的current, 要么找到它的前驱, 要么找到它的后继.

5、删除节点完整代码

 class Node {
            constructor(data) {
                this.left = null;
                this.data = data;
                this.right = null;
            }
        }
        class BST {
            constructor() {
                this.root = null;
            }
            // 1.插入
            insert(ele) {
                // 创建新节点
                let newnode = new Node(ele);
                // console.log(newnode);
                if (this.root == null) { // 空树
                    this.root = newnode
                } else {
                    this.insertNode(this.root, newnode)
                }
            }
            insertNode(root, newnode) {
                if (newnode.data < root.data) { // 放左边
                    if (root.left == null) {
                        root.left = newnode
                    } else {
                        this.insertNode(root.left, newnode)
                    }
                } else { //放右边
                    if (root.right == null) {
                        root.right = newnode
                    } else {
                        this.insertNode(root.right, newnode)
                    }
                }
            }
            // 2.前序遍历
            preOrderTraversal() {
                this.preOrderTraversalNode(this.root)
            }
            preOrderTraversalNode(root) {
                if (root != null) { // {left:node,data:11,right:node} != null
                    // 1.根
                    console.log(root.data); //11 7  15
                    // 2.前序遍历左子树
                    this.preOrderTraversalNode(root.left)
                    // 3.前序遍历右子树
                    this.preOrderTraversalNode(root.right)
                }
            }
            // 3.中序遍历
            inOrderTraversal() {
                this.inOrderTraversalNode(this.root)
            }
            inOrderTraversalNode(root) {
                if (root != null) {
                    // 1.中序遍历左子树
                    this.inOrderTraversalNode(root.left)
                    // 2.根
                    console.log(root.data);
                    // 3.中序遍历右子树
                    this.inOrderTraversalNode(root.right)
                }
            }
            // 4.后序遍历
            postOrderTraversal() {
                this.postOrderTraversalNode(this.root)
            }
            postOrderTraversalNode(root) {
                if (root != null) {
                    // 1.后序遍历左子树
                    this.postOrderTraversalNode(root.left)

                    // 2.后序遍历右子树
                    this.postOrderTraversalNode(root.right)
                    // 3.根
                    console.log(root.data);
                }
            }
            // 5.最值
            getMin() {
                if (this.root == null) {
                    return
                } else {
                    let current = this.root;

                    while (current.left != null) {
                        current = current.left
                    }
                    return current.data
                }
            }
            getMax() {
                if (this.root == null) {
                    return
                } else {
                    let current = this.root;

                    while (current.right != null) {
                        current = current.right
                    }
                    return current.data
                }
            }
            remove(ele) {
                if (this.root == null) return
                let current = this.root,
                    parent, isLeftChild;
                // 找到删除节点和父节点,判断是左子节点吗?
                while (ele != current.data) {
                    if (ele < current.data) {
                        //左边找
                        parent = current;
                        current = current.left;
                        isLeftChild = true;
                    } else {
                        parent = current;
                        current = current.right;
                        isLeftChild = false;
                    }
                }
                let delNode = current;
                // console.log(`当前删除的元素是${current.data},删除元素的父节点是${parent.data},是左孩子吗?${isLeftChild}`);
                // 1.删除叶结点   左右子树都为空
                if (delNode.left == null && delNode.right == null) {
                    if (delNode == this.root) {
                        this.root = null;
                    } else {
                        if (isLeftChild) {
                            //左孩子
                            parent.left = null;
                        } else {
                            parent.right = null;
                        }
                    }
                } else if (delNode.left != null && delNode.right == null) { //2.只有一个左子节点的节点
                    if (delNode == this.root) {
                        this.root = delNode.left
                    } else {
                        if (isLeftChild) {
                            parent.left = delNode.left
                        } else {
                            parent.right = delNode.left
                        }
                    }
                } else if (delNode.left == null && delNode.right != null) { //只有一个右子节点的节点
                    if (delNode == this.root) {
                        this.root = delNode.right
                    } else {
                        if (isLeftChild) {
                            parent.left = delNode.right
                        } else {
                            parent.right = delNode.right
                        }
                    }
                } else { //删除有两个子节点    
                    let houji = this.gethouji(delNode);//后继为右子树中的最小值
                    if (delNode == this.root) {
                        this.root = houji;
                    } else {
                        if (isLeftChild) {
                            parent.left = houji;
                        } else {
                            parent.right = houji;
                        }
                    }
                    houji.left = delNode.left;
                }
            }
            gethouji(delNode) {
                let current = delNode.right; //后继
                let houjiparent = delNode;
                while (current.left != null) {
                    houjiparent = current;
                    current = current.left;
                }
                if (current != delNode.right) { //当后继为删除节点的右节点
                    houjiparent.left = current.right;
                    current.right = delNode.right
                }
                return current
            }
            seacrh(ele) {
                if (this.root == null) return
                let current = this.root;
                while (current) {
                    if (ele < current.data) {
                        //左边找
                        current = current.left
                    } else if (ele > current.data) {
                        current = current.right;
                    } else {
                        return true
                    }
                }
                return false
            }
        }
        let bst = new BST();
        bst.insert(11)
        bst.insert(7)
        console.log(bst.seacrh(9));
        console.log(bst.seacrh(100));