BST 搜索二叉树 JS 中序遍历先序遍历后序遍历删除节点

最新推荐文章于 2024-08-27 14:02:57 发布

优价实习

最新推荐文章于 2024-08-27 14:02:57 发布

阅读量134

点赞数

分类专栏：数据结构文章标签：数据结构二叉树 js

本文链接：https://blog.csdn.net/weixin_44828588/article/details/114671246

版权

数据结构专栏收录该内容

16 篇文章 0 订阅

订阅专栏

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        function BinarySearchtree() {
            function Node(key) {

                this.key = key;
                this.left = null;
                this.right = null;
            }
            // console.log("1")
            this.root = null
                //Bst方法
            BinarySearchtree.prototype.insert = function(key) {
                //根据key创建节点
                var newNode = new Node(key)
                    // console.log("s")
                    //判断是否有root
                if (this.root == null) {
                    this.root = newNode

                } else {

                    this.insertNode(this.root, newNode)

                }

            }
            BinarySearchtree.prototype.insertNode = function(node, newNode) {
                if (newNode.key < node.key) {

                    if (node.left == null) {
                        node.left = newNode
                    } else {
                        this.insertNode(node.left, newNode)
                    }
                } else {
                    if (node.right == null) {
                        node.right = newNode
                    } else {
                        this.insertNode(node.right, newNode)
                    }
                }
            }
            BinarySearchtree.prototype.search = function(key) {
                var node = this.root
                while (node != null) {
                    // console.log(1)
                    if (key < node.key) {
                        node = node.left
                    } else if (key > node.key) {
                        node = node.right
                    } else {
                        return true;
                        // console.log(1)
                    }

                }
                return false
            }
            BinarySearchtree.prototype.remove = function(key) {

                    //1。寻找删除的节点
                    // 1.1 定义变量，保存删除节点
                    var current = this.root
                    var parent = null
                    var isLeftChild = true;
                    // 1.2 开始寻找
                    while (current.key != key) {

                        parent = current
                        if (key < current.key) {
                            isLeftChild = true
                            current = current.left;
                        } else {
                            isLeftChild = false
                            current = current.right
                        }
                        //如果没有找
                        if (current == null) {
                            return false
                        }
                    }

                    //2。删除
                    // 2.1删除叶子节点
                    if (current.left == null && current.right == null) {
                        if (current == this.root) {
                            this.root = null;
                        } else if (isLeftChild) {
                            parent.left = null;

                        } else {
                            parent.right = null
                        }
                        // 2.2删除节点只有一个子节点
                    } else if (current.right == null) {
                        if (current == this.root) {
                            this.root = current.left
                        } else if (isLeftChild) {
                            parent.left = current.left;

                        } else {
                            parent.right = current.left
                        }
                    } else if (current.left == null) {
                        if (current == this.root) {
                            this.root = current.right
                        } else if (isLeftChild) {
                            parent.left = current.right;

                        } else {
                            parent.right = current.right
                        }
                    } else {
                        var successor = this.getSucessor(current)
                        if (current == this.root) {
                            this.root = successor
                        } else if (isLeftChild) {
                            parent.left = successor
                        } else {
                            parent.right = successor
                        }
                        //3.删除节点左子树
                        successor.left = current.left

                    }
                }
                //获取后继
            BinarySearchtree.prototype.getSucessor = function(delNode) {
                    var successor = delNode;
                    var current = delNode.right;
                    var successorParent = delNode
                    while (current != null) {
                        successor = current
                        current = current.left
                    }
                    //判断寻找后继是否为直接delNode的right
                    if (successor != delNode.right) {
                        successorParent.left = delNode.right
                        successor.right = delNode.right

                    }
                    return successor
                }
                //获取前ji
                // BinarySearchtree.prototype.getSucessor = function() {

            // }
            BinarySearchtree.prototype.preOrderTraveral = function(handler) {
                this.preOrderTraveralNode(this.root, handler)
            }
            BinarySearchtree.prototype.preOrderTraveralNode = function(node, handler) {
                if (node != null) {
                    handler(node.key)
                    this.preOrderTraveralNode(node.left, handler)
                    this.preOrderTraveralNode(node.right, handler)
                }
            }
            BinarySearchtree.prototype.midOrdertraveral = function(handler) {
                this.midOrdertraveralNode(this.root, handler)
            }
            BinarySearchtree.prototype.midOrdertraveralNode = function(node, handler) {
                if (node != null) {
                    this.midOrdertraveralNode(node.left, handler)
                    handler(node.key)
                    this.midOrdertraveralNode(node.right, handler)

                }
            }
            BinarySearchtree.prototype.LasOrdertraveral = function(handler) {
                this.LasOrdertraveralNode(this.root, handler)
            }
            BinarySearchtree.prototype.LasOrdertraveralNode = function(node, handler) {
                if (node != null) {
                    this.LasOrdertraveralNode(node.left, handler)

                    this.LasOrdertraveralNode(node.right, handler)
                    handler(node.key)
                }
            }

            BinarySearchtree.prototype.Max = function() {
                //1.获取根节点
                var node = this.root;
                //2.依次向又不断查找
                var key = null
                while (node != null) {
                    key = node.key
                    node = node.right
                }
                return key
            }
            BinarySearchtree.prototype.Min = function() {
                //1.获取根节点
                var node = this.root;
                //2.依次向又不断查找
                var key = null
                while (node != null) {
                    key = node.key
                    node = node.left
                }
                return key
            }
        }



        var bst = new BinarySearchtree()
        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(15);
        bst.insert(6)
            //遍历测试
        console.log(bst)

        //先序遍历
        var resultString = "";
        bst.preOrderTraveral(function(key) {
            resultString += key + " "
        })
        console.log("先序遍历=" + resultString)
            //中序遍历
        var resultString = "";
        bst.midOrdertraveral(function(key) {
            resultString += key + " "
        })
        console.log("中序遍历=" + resultString)
            //后续
        var resultString = "";
        bst.LasOrdertraveral(function(key) {
            resultString += key + " "
        })
        console.log("后序遍历=" + resultString)
            //最大
        console.log("最大=" + bst.Max())
            //最小
        console.log("最小=" + bst.Min())
            //测试搜索
        console.log(bst.search(23), bst.search(21), bst.search(2), bst.search(3), bst.search(13))
            //测试删除操作
        bst.remove(3)
        bst.remove(13)
        console.log(bst.search(23), bst.search(21), bst.search(2), bst.search(3), bst.search(13))
    </script>
</body>

</html>

优价实习

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
BST 搜索二叉树 JS 中序遍历先序遍历后序遍历删除节点

<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>D.
复制链接

扫一扫