JavaScript实现二叉树遍历、查询、删除

JavaScript实现数据结构可以提高我们的效率，本文介绍JavaScript实现二叉树的遍历。

二叉树中序、前序、后序遍历大家应该了解，指的是根节点遍历的顺序

首先我们建立一个二叉查找树（二叉排序树），从开始节点作为根节点，对其遍历插入，具体代码如下：

function BinaryTree(){
	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);
	    }
	};
}

实现二叉排序树的中序遍历，在function里面加入以下程序：

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 nodes =[8,5,7,10,6];
    var binaryTree = new BinaryTree();
    nodes.forEach(function(key){
    	binaryTree.insert(key);
    });

    var callback = function(key){
    console.log(key);
    }

    binaryTree.inOrderTraverse(callback);

对其进行后序遍历和先序遍历的程序类似，只是在遍历顺序上进行了变化，下面给出完整代码：

function BinaryTree(){
	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);// 给一个接口后具体实现的方法
	}
}
    var nodes =[8,5,7,10,6];
    var binaryTree = new BinaryTree();
    nodes.forEach(function(key){
    	binaryTree.insert(key);
    });

    var callback = function(key){
    console.log(key);
    }
    console.log("中序遍历为：")
	binaryTree.inOrderTraverse(callback);
	console.log("前序遍历为：")
    binaryTree.preOrderTraverse(callback);
    console.log("后序遍历为：")
    binaryTree.postOrderTraverse(callback)；

运行结果为：

中序遍历为：
5
6
7
8
10
前序遍历为：
8
5
7
6
10
后序遍历为：
6
7
5
10
8
[Finished in 0.3s]

下面实现二叉树的查询，首先实现找二叉树的最大最小值，区别在于最小值一直遍历左子树，而最大值一直在遍历右子树，这里列出找最小值：

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

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

下面实现二叉树元素的查询，存在返回true,不存在返回false:

	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.search = function(key){
		return searchNode(root,key);
	}

二叉树结点的删除比较复杂，需要分情况讨论：

1、叶结点   

2、有一个子节点的结点

3、有两个孩子的结点，这个需要找到要删除的结点的右子树的结点中最小的结点放在要删除的结点位置上，之后删除该最小结点；这里用到刚才的min函数方法。

	var removeNode = function(node, key){
		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);
		}else{
			if(node.left === null && node.right==null){
				node = null;
				return node;
			}
			if(node.right === null){
				node = node.right;
				return node;
			}else if(node.left === null){
				node = node.left;
				return node;
			}

			var aux = minNode(node.right);
			node.key = aux.key;
			node.right = removeNode(node.right,key);
			return node;
		}

	}

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