javascript数据结构与算法（笔记）---树

<script>
    /*
    *树类中实现的方法
    * insert(key): 向树中插入一个新的键
    * search(key): 在树中查找一个键，如果节点存在，则返回true，如果不存在则返回false
    * inOrderTraverse: 通过中序遍历方式遍历所有节点
    * preOrderTraverse: 通过先序遍历方式遍历所有节点
    * postOrderTraverse: 通过后序遍历方式遍历所有节点
    * min: 返回树中最小的值/键
    * max: 返回树中最大的值/键
    * remove(key): 从树中移除某个键
    * */
    function BinarySearchTree() {
      var Node = function(key) {
        this.key = key;
        this.left = null; // 链接树的左边
        this.right = null;// 链接树的右边
      }

      var root = null;

      var insertNode = function(node, newNode) {
        if(newNode.key < node.key) {
          if(node.left === null) {
            node.left = newNode;
          }else {
            insertNode(node.left, newNode);
          }
        }else {
          if(node.right === null) {
            node.right = newNode;
          }else {
            insertNode(node.right,newNode);
          }
        }
      }

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

      var inOrderTraverseNode = function(node, callback) {
        if(node !== null) {
          inOrderTraverseNode(node.left, callback);
          callback(node.key);
          inOrderTraverseNode(node.right, callback);
        }
      }

      this.inOrderTraverse = function(callback) { //中序:从最小到最大
        inOrderTraverseNode(root, callback);
      }

      var preOrderTraverseNode = function(node, callback) {
        if(node !== null) {
          callback(node.key);
          preOrderTraverseNode(node.left, callback);
          preOrderTraverseNode(node.right, callback)
        }
      }

      this.preOrderTraverse = function(callback) {
        preOrderTraverseNode(root, callback);
      }

      var postOrderTraverseNode = function(node, callback) {
        if(node !== null) {
          postOrderTraverseNode(node.left, callback);
          postOrderTraverseNode(node.right, callback);
          callback(node.key);
        }
      }

      this.postOrderTraverse = function(callback) {
        postOrderTraverseNode(root, callback);
      }

      this.min = function() {
        return minNode(root);
      }

      var minNode = function(node) {
        if(node) {
          while(node && node.left !== null) {
            node = node.left;
          }
          return node.key;
        }
        return null;
      }

      this.max = function() {
        return maxNode(root);
      }

      var maxNode = function(node) {
        if(node) {
          while(node && node.right !== null) {
            node = node.right;
          }
          return node.key;
        }
        return null;
      }

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

      var searchNode = function(node, key) {
        if(node === null) {
          return false;
        }
        if(key < node.key) {
          return searchNode(node.left, key);
        }else if (key > node.key) {
          return searchNode(node.right,key);
        }else {
          return true;
        }
      }

      this.remove = function(key) {
        root = removeNode(root, key);//1
      }

      var removeNode = function(node, key) {
        if(node === null) { //2
          return null;
        }
        if(key < node.key) {//3
          node.left = removeNode(node.left, key);//4
          return node;//5
        }else if (key > node.key) {//6
          node.right = removeNode(node.right, key);//7
          return node;//8
        }else { //键等于node.key
          // 第一种情况--一个叶节点
          if(node.left === null && node.right === null) { //9
            node = null;//10
            return node;// 11
          }

          // 第二种情况--一个只有一个子节点的节点
          if(node.left === null) {//12
            node = node.right;//13
            return node;//14
          }else if (node.right === null) {//15
            node = node.left;//16
            return node;//17
          }

          // 第三种情况--一个只有两个子节点的节点
          var aux = findMinNode(node.right); //18
          node.key = aux.key;//19
          node.right = removeNode(node.right, aux.key);//20
          return node;
        }
      }
    } 

    var tree = new BinarySearchTree();

    tree.insert(11);
    tree.insert(7);
    tree.insert(15);
    tree.insert(5);
    tree.insert(20);

    function printNode(value) {
      console.log(value);
    }
    
    tree.preOrderTraverse(printNode)
  </script>