二叉树``` 乘风破浪，破浪破破破破破。。。只是为了好学习感觉大佬--> 。。。千峰教育。。。 ```

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>二叉树</title>
  </head>
  <body>
    <script type="text/javascript">
      const Compare = {
        less: -1,
        bigger: 1,
        equ: 0,
      };

      class Node {
        constructor(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }
      }
      class BST {
        constructor() {
          this.root = null;
        }
        //二叉树插入
        insert(key) {
          if (this.root == null) {
            this.root = new Node(key);
          } else {
            this.insertNode(this.root, key);
          }
        }
        compareFn(a, b) {
          if (a === b) {
            return Compare.equ;
          }
          return a < b ? Compare.less : Compare.bigger;
        }
        insertNode(node, key) {
          if (this.compareFn(key, node.key) === Compare.less) {
            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);
            }
          }
        }
        //二叉树遍历
        //   //中序遍历
        inOrderMap(callback) {
          this.inOrderMapNode(this.root, callback);
        }
        //inOrderMapNode 70 80 90 100 110 从小到大
        inOrderMapNode(node, callback) {
          if (node != null) {
            this.inOrderMapNode(node.left, callback); //左先走完再到后面
            callback(node.key);
            this.inOrderMapNode(node.right, callback);
          }
        }
        //先序遍历
        preOrderMap(callback) {
          this.preOrderMapNode(this.root, callback);
        }
        //preOrderMapNode :父--子所有左--子右 100 80 70 90 110
        preOrderMapNode(node, callback) {
          if (node != null) {
            callback(node.key);
            this.preOrderMapNode(node.left, callback); //左先走完再到后面
            this.preOrderMapNode(node.right, callback);
          }
        }
        //后序遍历
        postOrderMap(callback) {
          this.postOrderMapNode(this.root, callback);
        }
        //postOrderMapNode :从下到上 70 90 80 110 100
        postOrderMapNode(node, callback) {
          if (node != null) {
            this.postOrderMapNode(node.left, callback); //左先走完再到后面
            this.postOrderMapNode(node.right, callback);
            callback(node.key);
          }
        }
        min() {
          return this.minNode(this.root);
        }
        minNode(node) {
          let current = node;
          while (current != null && current.left != null) {
            current = current.left;
          }
          return current;
        }
        max() {
          return this.maxNode(this.root);
        }
        maxNode(node) {
          let current = node;
          while (current != null && current.right != null) {
            current = current.right;
          }
          return current;
        }
        search(key) {
          return this.searchNode(this.root, key);
        }
        searchNode(node, key) {
          if (node === null) return false;
          if (this.compareFn(key, node.key) === Compare.less) {
            return this.searchNode(node.left, key);
          } else if (this.compareFn(key, node.key) === Compare.bigger) {
            return this.searchNode(node.right, key);
          } else {
            return true;
          }
        }
      }

      var mytree = new BST();
      //mytree.insert(100)----test1 80 70 90 110
      //test2
      mytree.insert(100);
      mytree.insert(80);
      mytree.insert(70);
      mytree.insert(90);
      mytree.insert(110);
      // mytree.inOrderMap((value) => {
      //   console.log("中序遍历", value);//70 80 90 100 110--
      // });
      // mytree.preOrderMap((value) => {
      //   console.log("先序遍历", value);//100 80 70 90 110--左走完到右
      // });
      mytree.postOrderMap((value) => {
        console.log("后序遍历", value); //70 90 80 110 100 --左右父
      });

      mytree.min();
      mytree.max();

      // 中序遍历是一种从最小到最大
      // 先序：打结构化的文档（C-->c1/c2）
      // 后序：计算一个目录及其子目录中所有文件占空间的大小
    </script>
  </body>
</html>
乘风破浪，破浪破破破破破。。。
只是为了好学习
感觉大佬-->
。。。千峰教育。。。