JavaScript树(二) 二叉树搜索

TypeScript方式实现源码

 // 二叉树与二叉树搜索
 class Node {
     key;
     left;
     right;
     constructor(key) {
         this.key = key;
         this.left = null;
         this.right = null;
     }
 }
 class BinarySearchTree {
     root = null;
     public insert(key) {
         let newNode = new Node(key);

         if (this.root === null) {
             this.root = newNode;
         } else {
             this.insertNode(this.root, newNode);
         }
     }
     private insertNode(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);
             }
         }
     }
     public search(key) {
         return this.searchNode(this.root, key);
     }
     private searchNode(node, key) {
         if (node === null) {
             return false;
         }
         if (key < node.key) {
             return this.searchNode(node.left, key);
         } else if (key > node.key) {
             return this.searchNode(node.right, key);
         } else {
             return true;
         }
     }
     /**
      * 中序遍历
      */
     public inOrderTraverse(callback) {
         this.inOrderTraverseNode(this.root, callback);
     }
     private inOrderTraverseNode(node, callback) {
         if (node !== null) {
             this.inOrderTraverseNode(node.left, callback);
             callback(node.key);
             this.inOrderTraverseNode(node.right, callback);
         }
     }
     /**
      * 先序遍历
      */
     public preOrderTraverse(callback) {
         this.preOrderTraverseNode(this.root, callback)
     }
     private preOrderTraverseNode(node, callback) {
         if (node !== null) {
             callback(node.key);
             this.preOrderTraverseNode(node.left, callback);
             this.preOrderTraverseNode(node.right, callback);
         }
     }
     /**
      * 后序遍历
      */
     public postOrderTraverse(callback) {
         this.postOrderTranverseNode(this.root, callback)
     }
     private postOrderTranverseNode(node, callback) {
         if (node !== null) {
             this.postOrderTranverseNode(node.left, callback);
             this.postOrderTranverseNode(node.right, callback);
             callback(node.key);
         }
     }
     public min() {

     }
     private minNode(node) {
         if (node) {
             while (node && node.left !== null) {
                 node = node.left;
             }
             return node.key;
         }
         return null;
     }
     public max(node) {
         if (node) {
             while (node && node.right !== null) {
                 node = node.right;
             }
             return node.key;
         }
         return null;
     }
     public remove(key) {
         this.root = this.removeNode(this.root, key);
     }
     private removeNode(node, key) {
         if (node === null) {
             return null;
         }
         if (key < node.key) {
             node.left = this.removeNode(node.left, key);
             return node;
         } else if (key > node.key) {
             node.right = this.removeNode(node.right, key);
             return node;
         } else { // 建等于node.key
             // 第一种情况——一个叶节点
             if (node.left === null && node.right === null) {
                 node = null;
                 return node;
             }

             // 第二种情况——一个只有一个子节点的节点
             if (node.left === null) {
                 node = node.right;
                 return node;
             } else if (node.right === null) {
                 node = node.left;
                 return node;
             }

             // 第三种情况——一个只有两个子节点的节点
             let aux = findMinNode(node.right);
             node.key = aux.key;
             node.right = this.removeNode(node.right, aux.key);
             return node;
         }
     }
 }
 function printNode(value) {
     console.log(value);
 }
 let tree = new BinarySearchTree();
 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();

 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();
 tree.insert();

 // tree.inOrderTraverse(printNode);
 // tree.preOrderTraverse(printNode);
 tree.postOrderTraverse(printNode);

 console.log(tree.search() ? 'Key 1 found.' : 'Key 1 not found.');
 console.log(tree.search() ? 'Key 8 found.' : 'Key 8 not found.');

二叉树 BinarySearchTree

二叉树和二叉搜索树

　　二叉树中的节点最多只能有两个子节点：一个是左侧子节点，另一个是右侧子节点。这些定
义有助于我们写出更高效的向/从树中插入、查找和删除节点的算法。二叉树在计算机科学中的
应用非常广泛。
　　二叉搜索树（BST）是二叉树的一种，但是它只允许你在左侧节点存储（比父节点）小的值，
在右侧节点存储（比父节点）大（或者等于）的值。上一节的图中就展现了一棵二叉搜索树。
二叉搜索树将是我们在本章中要研究的数据结构。

　　下图展现了二叉搜索树数据结构的组织方式：

　　

　　和链表一样，将通过指针来表示节点之间的关系（术语称其为边） 。在双向链表中，每个节
点包含两个指针，一个指向下一个节点，另一个指向上一个节点。对于树，使用同样的方式（也
使用两个指针） 。但是，一个指向左侧子节点，另一个指向右侧子节点。因此，将声明一个Node
类来表示树中的每个节点（行{1}） 。值得注意的一个小细节是，不同于在之前的章节中将节点
本身称作节点或项，我们将会称其为键。键是树相关的术语中对节点的称呼。
　　我们将会遵循和LinkedList类中相同的模式（第5章） ，这表示也将声明一个变量以控制此
数据结构的第一个节点。在树中，它不再是头节点，而是根元素（行{2}） 。
　　然后，我们需要实现一些方法。下面是将要在树类中实现的方法。
　　 insert(key)：向树中插入一个新的键。
　　 search(key)：在树中查找一个键，如果节点存在，则返回true；如果不存在，则返回false。 
　　 inOrderTraverse：通过中序遍历方式遍历所有节点。
　　 preOrderTraverse：通过先序遍历方式遍历所有节点。

　　 min：返回树中最小的值/键。
　　 max：返回树中最大的值/键。
　　 remove(key)：从树中移除某个键。
　　我们将在后面的小节中实现每个方法。

向树中插入一个键

　　要向树中插入一个新的节点（或项） ，要经历三个步骤。
　　第一步是创建用来表示新节点的Node类实例（行{1}） 。只需要向构造函数传递我们想用来
插入树的节点值，它的左指针和右指针的值会由构造函数自动设置为null。
　　第二步要验证这个插入操作是否为一种特殊情况。 这个特殊情况就是我们要插入的节点是树
的第一个节点（行{2}） 。如果是，就将根节点指向新节点。
　　第三步是将节点加在非根节点的其他位置。

树的遍历

　　遍历一棵树是指访问树的每个节点并对它们进行某种操作的过程。但是我们应该怎么去做
呢？应该从树的顶端还是底端开始呢？从左开始还是从右开始呢？访问树的所有节点有三种方
式：中序、先序和后序。

中序遍历

　　中序遍历是一种以上行顺序访问BST所有节点的遍历方式， 也就是以从最小到最大的顺序访
问所有节点。中序遍历的一种应用就是对树进行排序操作。

this.inOrderTraverse = function(callback){
    inOrderTraverseNode(root, callback); //{1}
}; 

　　inOrderTraverse方法接收一个回调函数作为参数。回调函数用来定义我们对遍历到的每
个节点进行的操作（这也叫作访问者模式，要了解更多关于访问者模式的信息，请参考http://en.
wikipedia.org/wiki/Visitor_pattern） 。由于我们在BST中最常实现的算法是递归，这里使用了一个
私有的辅助函数，来接收一个节点和对应的回调函数作为参数（行{1}） 。

var inOrderTraverseNode = function (node, callback) {
    if (node !== null) { //{2}
        inOrderTraverseNode(node.left, callback);  //{3}
        callback(node.key);                        //{4}
        inOrderTraverseNode(node.right, callback); //{5}
    }
}; 

　　要通过中序遍历的方法遍历一棵树，首先要检查以参数形式传入的节点是否为null（这就
是停止递归继续执行的判断条件——行{2}——递归算法的基本条件） 。
　　然后，递归调用相同的函数来访问左侧子节点（行{3}） 。接着对这个节点进行一些操作
（callback） ，然后再访问右侧子节点（行{5}） 。
　　我们试着在之前展示的树上执行下面的方法：

function printNode(value){ //{6}
    console.log(value);
}
tree.inOrderTraverse(printNode); //{7} 

　　但首先，需要创建一个回调函数（行{6}） 。我们要做的，是在浏览器的控制台上输出节点
的值。然后，调用inOrderTraverse方法并将回调函数作为参数传入（行{7}） 。当执行上面的

　　代码后，下面的结果将会在控制台上输出（每个数字将会输出在不同的行） ：
　　3 5 6 7 8 9 10 11 12 13 14 15 18 20 25
　　下面的图描绘了inOrderTraverse方法的访问路径：