JavaScript数据结构之 二叉排序树

/**
* 二叉排序树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），亦称二叉搜索树。
* 左边子节点的值 < 父节点的值 < 右边子节点的值
* 包括的方法有：插入、遍历、查询、查询父节点、右树上最小节点、
* 前中后序遍历、清空、删除、是否为空、求宽度、求深度
*/

function BinarySortTree(value){
this.root = null;
if(typeof value === "number"){
this.root = this.insert(value);
}else{
return false;
}
}
BinarySortTree.prototype = {
//创建节点
createNode: function(value){
return {
value:value,
left:null,
right:null
};
},
//插入一个新节点，如果没有root就创建root
insert: function(value){
if(typeof value !== "number"){
return false;
}
var node = this.createNode(value);
if(!this.root){
this.root = node;
return this.root;
}else{
return this.insertNode(this.root, node);
}
},
//通过递归来插入
insertNode: function(fNode, newNode){
if(fNode.value>newNode.value){
if(fNode.left===null){
fNode.left = newNode;
return newNode;
}else{
return this.insertNode(fNode.left, newNode);
}
}else if(fNode.value<newNode.value){
if(fNode.right===null){
fNode.right = newNode;
return newNode;
}else{
return this.insertNode(fNode.right, newNode);
}
}else{
return false;
}
},
//查找第一个值相同的节点
findFirst: function(value){
console.log(this.root);
if(!this.root)return false;
return this.findFirstNode(this.root, value)
},
//采用的是前序查找 中>左>右
findFirstNode: function(node, value){
if(node === null)return false;
if(node.value === value)return node;
else if(node.value > value){
return this.findFirstNode(node.left, value);
}
else{
return this.findFirstNode(node.right, value);
}
},
//判断空树
isEmpty: function(){
if(this.root)return false;
return true;
},
//清空二叉树
clear: function(){
this.clearTree(this.root);
this.root = null;
},
//清理某个子树, 需要找到父节点，然后设为null，不能直接将node设为null
clearTree: function(node){
if(node === null)return;
this.clearTree(node.left);
this.clearTree(node.right);
var fNode = this.findFather(node);
if(fNode.left === node)fNode.left=null;
else if(fNode.right === node)fNode.right=null;
},
//寻找父节点
findFather: function(node){
return this.findFatherNode(this.root,node);
},
findFatherNode: function(fNode, node){
if(fNode===null)return false;
if(fNode.left === node || fNode.right === node)return fNode;
if(fNode.value>node.value)return this.findFatherNode(fNode.left, node);
else return this.findFatherNode(fNode.right, node);
},
//计算二叉树深度
getDepth: function(){
return this.getTreeDepth(this.root);
},
//计算子树深度
getTreeDepth: function(node){
if(node === null)return 0;
var leftDepth = this.getTreeDepth(node.left) + 1;
var rightDepth = this.getTreeDepth(node.right) + 1;

if(leftDepth>rightDepth)
return leftDepth;
return rightDepth;
},
//计算树的宽度
getWidth: function(){
return this.getLeftTreeWidth(this.root)+this.getRightTreeWidth(this.root)-1;
},
//计算子树宽度
getLeftTreeWidth: function(node){
if(node === null)return 0;
return 1+this.getLeftTreeWidth(node.left);
},
getRightTreeWidth: function(node){
if(node === null)return 0;
return 1+this.getRightTreeWidth(node.right);
},
//前序遍历
preOrderTraverse: function(callback){
this.preOrderTraverseNode(this.root, callback);
},
preOrderTraverseNode: function(node, callback){
if(node === null)return;
//left
this.preOrderTraverseNode(node.left, callback);
//callback
callback(node.value);
//right
this.preOrderTraverseNode(node.right, callback);
},

//中序遍历
inOrderTraverse: function(callback){
this.inOrderTraverseNode(this.root, callback);
},
inOrderTraverseNode: function(node, callback){
if(node === null)return;
//callback
callback(node.value);
//left
this.inOrderTraverseNode(node.left, callback);
//right
this.inOrderTraverseNode(node.right, callback);
},

//后序遍历
postOrderTraverse: function(callback){
this.postOrderTraverseNode(this.root, callback);
},
postOrderTraverseNode: function(node, callback){
if(node === null)return;
//left
this.postOrderTraverseNode(node.left, callback);
//right
this.postOrderTraverseNode(node.right, callback);
//callback
callback(node.value);
},
//找到右树的最小值
findRightMinNode: function(node){
if(node.left===null)return node;
else return this.findRightMinNode(node.left);
},

//移除
remove: function(value){
return this.removeNode(this.root, value);
},
removeNode: function(node, value){
var targetNode = this.findFirstNode(node, value);
var fNode = this.findFather(targetNode);
if(targetNode===this.root){
return false;//暂不考虑移除根节点情况
}
//target为叶子节点
if(targetNode.left===null&&targetNode.right===null){
fNode.left === targetNode?fNode.left=null:fNode.right=null;
return true;
}
//target只有一个子节点
if(targetNode.left===null&&targetNode.right){
fNode.left === targetNode?fNode.left=targetNode.right:fNode.right=targetNode.right;
delete targetNode.value;
delete targetNode.right;
delete targetNode.left;
return true;
}
if(targetNode.right===null&&targetNode.left){
fNode.left === targetNode?fNode.left=targetNode.left:fNode.right=targetNode.left;
delete targetNode.value;
delete targetNode.right;
delete targetNode.left;
return true;
}
//target有两个子节点
var minNode = this.findRightMinNode(targetNode.right);
targetNode.value = minNode.value;
return this.removeNode(targetNode.right, targetNode.value);
}
};

var root = new BinarySortTree(0);
root.insert(1);
root.insert(2);
root.insert(8);
root.insert(4);
root.insert(9);
root.insert(-7);
root.insert(-1);
root.insert(-8);

console.log(root);