二叉树容器更快捷的对数据(增删改查)

最新推荐文章于 2024-04-26 21:06:15 发布

舜岳

最新推荐文章于 2024-04-26 21:06:15 发布

阅读量131

点赞数

分类专栏： js设计模式文章标签： JavaScript

本文链接：https://blog.csdn.net/qq_41614928/article/details/101145747

版权

js设计模式专栏收录该内容

21 篇文章 0 订阅

订阅专栏

效果图：

二叉树容器更快捷的对数据: 增删改查：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>二叉树容器</title>
</head>
<body>
  <script>
    //二叉树容器 查找更快
    let BST = (function(){
      let root = Symbol();
      //创建对应的类 来存储左右节点
      class Node{
        constructor(key){
          this.key = key;
          this.left = null;
          this.right = null;
        }
      }
      //用于插入的递归函数
      function insertNode(root,node){
        if(node.key < root.key){
          if(root.left){
            insertNode(root.left,node)
          }else{
            root.left = node;
          }
        }else{
          if(root.right){
            insertNode(root.right,node)
          }else{
            root.right = node;
          }
        }
      }
      //用于中序遍历的递归函数
      function inOrderTraverseNode(root,arr){
        if( !root ) return;
        inOrderTraverseNode(root.left,arr)
        arr.push(root.key);
        inOrderTraverseNode(root.right,arr)
      }
      //先序遍历的递归函数(作用不大)
      function preOrderTraverseNode(root,arr){
        if( !root ) return;
        arr.push(root.key);
        inOrderTraverseNode(root.left,arr)
        inOrderTraverseNode(root.right,arr)
      }
      //后序遍历的递归函数(作用不大)
      function postOrderTraverseNode(root,arr){
        if( !root ) return;
        inOrderTraverseNode(root.left,arr)
        inOrderTraverseNode(root.right,arr)
        arr.push(root.key);
          
      }
      //用于判断值是否存在的递归函数
      function ishas(root,key){
        if(key == root.key)return true;
        if(key < root.key){
          if(root.left) return ishas(root.left,key)
          else return false;
        }else{
          if(root.right)return ishas(root.right,key);
          else return false;
        }
      }
      //用于删除节点
      function removeNode(root,key,zhong){
        if(key == root.key){
          let left = root.left;
          let right = root.right;
          //存在right节点的情况
          if(right){
            while(right.left){
              right = right.left;
            }
            right.left = left;
          }
          //是否是删除根节点
          if(zhong !=undefined){
            //根节点有无right 分两种情况
            right? root = root.right : root = root.left;
          };
          return root;
        };
        if(key < root.key){
          if(root.left){
            let top = removeNode(root.left,key)
            if(top.right){
              root.left= top.right;
            }else if(top){
              root.left= top.left;
            }
            return false
          }else return false;
        }
        if(key > root.key){
          if(root.right){
            let top = removeNode(root.right,key)
            if(top.right){
              root.right= top.right;
            }else if(top){
              root.right= top.left;
            }
            return false
          }else return false;
        }
        return root
      }

      return class{
        constructor(){
          this[root] = null;
        }
        //插入值
        insert(key){
          let node = new Node(key),
              Root = this[root];
          //root不存在表示第一次存值
          if(!Root){
            this[root] = node;
          }else{
            insertNode(Root, node);
          }
        }
        //按顺序提取所有数据
        inOrderTraverse(){
          let arr = [];
          inOrderTraverseNode(this[root], arr);
          return arr;
        }
        //得到最大值
        getMax(){
          let Root = this[root];
          if(!Root)return undefined;
          while (Root.right){
            Root = Root.right
          }
          return Root.key;
        }
        //得到最小值
        getMin(){
          let Root = this[root];
          if(!Root)return undefined;
          while (Root.left){
            Root = Root.left
          }
          return Root.key;
        }
        //判断是否存在
        has(key){
          return ishas(this[root],key);
        }
        //删除
        remove(key){
          this[root] = removeNode(this[root],key,this[root].key)
          return this[root];
        }
      }
    })();

    let bst = new BST;
    bst.insert(20);
    bst.insert(10);bst.insert(8); bst.insert(12);bst.insert(11);bst.insert(13);
    bst.insert(25);bst.insert(31);bst.insert(22);bst.insert(21);bst.insert(23);bst.insert(28);
    // console.log(bst);
    console.log(bst.inOrderTraverse()); //[8, 10, 11, 12, 13, 20, 21, 22, 23, 25, 28, 31]
    // console.log(bst.getMax());  //31
    // console.log(bst.getMin());  //8
    // console.log(bst.has(8));  //true
    // console.log(bst.has(24));  //false
    console.log(bst.remove(20));  //删除根节点
    // console.log(bst);
    console.log(bst.inOrderTraverse()); //[8, 10, 11, 12, 13, 21, 22, 23, 25, 28, 31]
  </script>
</body>
</html>