树是一种分层数据的抽象模型。
现实生活中最常见的例子是家谱，或是公司的组织架构。
一个树结构包含一系列父子关系的节点。每个节点都有一个父节点（除了顶部的第一个节点）以及零个或多个子节点。
来看下图中的树结构：
位于树顶部的节点叫做根节点，它没有父节点。
树中的每个元素都叫做节点，节点分为内部节点和外部节点。
至少有一个子节点的节点称为内部节点。
没有子元素的称为外部节点或也叶结点。
子树由节点和它的后代构成。
节点的一个属性是深度，节点的深度取决于它的祖先节点的数量。比如，节点3有3个祖先节点（5、7和11），所以它的深度为3。
树的高度取决于所有节点深度的最大值。
二叉树
二叉树中的节点最多只能有两个子节点：一个是左侧子节点，一个是右侧子节点。
二叉搜索树（BST）是二叉树的一种，但是它只允许在左侧节点存储（比父节点）小的值，在右侧节点存储（比父节点）大（或者等于）的值。
接下来，创建一个二叉树，基本结构如下：
/*二叉搜索树*/
function BinarySearchTree () {
/*
声明一个Node类，来表示树的每个节点。
*/
var Node = function(key){
this.key = key;
this.left = null;
this.right = null;
};
var root = null;//根元素
/*
insert(key)
像树中插入一个新的键
*/
this.insert = function(key){};
/*
search(key)
向树中查找一个键。
如果节点存在，则返回true；如果不存在，则返回false。
*/
this.search = function(key){};
/*
inOrderTraverse()
通过中序遍历方式遍历所有节点
*/
this.inOrderTraverse = function(){};
/*
preOrderTraverse()
通过先序遍历方式遍历所有节点
*/
this.preOrderTraverse = function(){};
/*
postOrderTraverse()
通过后序遍历方式遍历所有节点
*/
this.postOrderTraverse = function(){};
/*
min()
返回树中最小的值/键
*/
this.min = function(){};
/*
max()
返回树中最大的值/键
*/
this.max = function(){};
/*
remove(key)
从树中移除某个键
*/
this.remove = function(key){};
}1、向树中插入一个键
this.insert = function(key){
var newNode = new Node(key);
//如果插入的节点是第一个节点，就将根节点指向新节点。
if (root === null) {
root = newNode;
}
else {
insertNode(root,newNode);
}
};
//辅助函数，帮助我们找到新节点应该插入的正确位置。
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);
}
}
};下面的代码创建了上面图中的树。
var tree = new BinarySearchTree();
/*向树中插入键*/
tree.insert(11);
tree.insert(7);
tree.insert(15);
tree.insert(5);
tree.insert(3);
tree.insert(9);
tree.insert(8);
tree.insert(10);
tree.insert(13);
tree.insert(12);
tree.insert(14);
tree.insert(20);
tree.insert(18);
tree.insert(25);
tree.insert(6);2、树的遍历
1）中序遍历
以上行顺序访问BST所有节点的遍历方式，也就是以最小到最大的顺序访问所有节点。
中序遍历的一种应用就是对树进行排序操作。
this.inOrderTraverse = function(callback){
inOrderTraverseNode(root,callback);
};
var inOrderTraverseNode = function(node,callback){
if (node !== null) {
inOrderTraverseNode(node.left,callback);
callback(node.key);
inOrderTraverseNode(node.right,callback);
}
};测试代码如下：
/*中序遍历*/
function printNode(value){
console.log(value);
}
tree.inOrderTraverse(printNode);结果如下：
中序遍历的访问路径如下图所示。
2）先序遍历
以优先于后代节点的顺序访问每个节点，也就是说，先访问节点本身，再访问它的左侧子节点，最后是右侧子节点。
先序遍历的一种应用是打印一个结构化文档。
this.preOrderTraverse = function(callback){
preOrderTraverseNode(root,callback);
};
var preOrderTraverseNode = function(node,callback){
if (node !== null) {
callback(node.key);
preOrderTraverseNode(node.left,callback);
preOrderTraverseNode(node.right,callback);
}
};测试代码如下：
/*先序遍历*/
function printNode(value){
console.log(value);
}
tree.preOrderTraverse(printNode);结果如下：
访问路径如下所示。
3）后序遍历
先访问节点的后代节点，再访问节点本身。也就是说，先访问左侧子节点，然后是右侧子节点，最后是父节点本身。
后序遍历的一种应用是计算一个目录和它的子目录中所有文件所占空间的大小。
this.postOrderTraverse = function(callback){
postOrderTraverseNode(root,callback);
};
var postOrderTraverseNode = function(node,callback){
if (node !== null) {
postOrderTraverseNode(node.left,callback);
postOrderTraverseNode(node.right,callback);
callback(node.key);
}
};测试代码如下：
/*后序遍历*/
function printNode(value){
console.log(value);
}
tree.postOrderTraverse(printNode);结果如下：
访问路径如下所示。
3、搜索最小值和最大值
1）最小值
根据二叉树的特点，可以发现，树的最小值在树的最左端。
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;
};2）最大值
根据二叉树的特点，可以发现，树的最大值在树的最右端。
this.max = function(){
return maxNode(root);
};
var maxNode = function(node){
if (node) {
while (node && node.right !== null) {
node = node.right;
}
return node.key;
}
};测试代码：
/*最小值*/
console.log(tree.min());
/*最大值*/
console.log(tree.max());输出结果如下：
4、搜索一个特定的值
this.search = function(key){
return searchNode(root,key);
};
var searchNode = function(node,key){
//验证作为参数传入的node是否合法
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;
}
};测试代码：
console.log(tree.search(1) ? 'Key 1 found.' : 'Key 1 not found.');
console.log(tree.search(8) ? 'Key 8 found.' : 'Key 8 not found.');输出结果：
5、移除一个节点
this.remove = function(key){
root = removeNode(root,key);
};
var removeNode = function(node,key){
//检测的节点为null，则说明键不存在于树中
if (node === null) {
return null;
}
//如果要找的键比当前节点的值小，就沿着树的左边找到下一个节点
if (key < node.key) {
node.left = removeNode(node.left,key);
return node;
}
//如果要找的键比当前节点的值大，就沿着树的右边找到下一个节点
else if (key > node.key) {
node.right = removeNode(node.right,key);
return node;
}
//如果找到了要找的键
else {
//移除一个叶节点（没有左侧和右侧子节点的叶节点）
if (node.left === null && node.right === null) {
node = null;//给要移除的节点赋为null值
return node;//将对应的父节点指针赋为null值
}
//移除一个只有一个子节点的节点
/*跳过这个节点，直接将父节点指向它的指针指向子节点*/
//没有左侧子节点，只有一个右侧子节点
if (node.left === null) {
node = node.right;
return node;
}
//没有右侧子节点，只有一个左侧子节点
else if (node.right === null) {
node = node.left;
return node;
}
//移除有两个子节点的节点（左侧子节点和右侧子节点）
var findMinNode = function(node){
if (node) {
while (node && node.left !== null) {
node = node.left;
}
return node;//返回节点
}
return null;
};
var aux = findMinNode(node.right);//找到右边子树最小的节点
node.key = aux.key;//用右侧子树中最小节点的键区更新这个节点的值
node.right = removeNode(node.right,aux.key);//把右侧子树中的最小节点移除
return node;//向移动后的右侧树最小节点的父节点返回更新后节点的引用
}
};测试代码：
tree.remove(6);
console.log(tree.search(6) ? 'Key 6 found.' : 'Key 6 not found.');
tree.remove(5);
console.log(tree.search(5) ? 'Key 5 found.' : 'Key 5 not found.');
tree.remove(15);
console.log(tree.search(15) ? 'Key 15 found.' : 'Key 15 not found.');下面来分析一下移除这3个节点的过程，如下所示。
输出结果：
BST存在一个问题：取决于你添加的节点树，树的一条边可能会非常深；也就是说，树的一条分支会有很多层，而其他的分支却只有几层。
这会在需要在某条边上添加、移除和搜索某个节点时引起一些性能问题。
1519
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
