JS实现二叉树（前，中，后序遍历）

//二叉树方法
function BinaryTree(){
	let Node=function(key){
		this.key=key;
		this.left=null;
		this.right=null;
	}
	let root=null;
	let insertNode =(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=key=>{
		let newNode = new Node(key);
		if(root===null){
			root = newNode;
		}else{
			insertNode(root,newNode);
		}
	}
	//中序遍历
	let inOrderTraversNode =(node,callback)=>{
		if(node!=null){
			inOrderTraversNode(node.left,callback);
			callback(node.key);
			inOrderTraversNode(node.right,callback);
		}
	}
	this.inOrderTraverse=callback=>{
		inOrderTraversNode(root,callback);
	}
	
	//前序遍历
	let preOrderTraverseNode = (node,callback)=>{
		if(node!==null){
			callback(node.key);
			preOrderTraverseNode(node.left,callback);
			preOrderTraverseNode(node.right,callback);
		}
	}
	this.preOrderTraverse = callback=>{
		preOrderTraverseNode(root,callback)
	}
	
	//后续遍历
	let postOrderTraverseNode=(node,callback)=>{
		if(node!==null){
			postOrderTraverseNode(node.left,callback);
			postOrderTraverseNode(node.right,callback);
			callback(node.key);
		}
	}
	this.postOrderTraverse = callback=>{
		postOrderTraverseNode(root,callback);
	}
	
	//最小值查找
	let minNode=(node)=>{
		if(node){
			while(node&&node.left!==null){
				node=node.left
			}
			return node.key
		}
		return null
	}
	this.min=()=>{
		return minNode(root)
	}
	
	//最大值查找
	let maxNode=(node)=>{
		if(node){
			while(node&&node.right!==null){
				node=node.right
			}
			return node.key
		}
		return null
	}
	this.max=()=>{
		return maxNode(root)
	}
	
	//固定查找
	let searchNode=(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=key=>{
		return searchNode(root,key)
	}
	
	//节点删除
	let findMinNode=node=>{
		if(node){
			while(node&&node.left!==null){
				node=node.left;
			}
			return node;
		}
		return null
	}
	let removeNode = (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.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 =removeNode(node.right,aux.key);
			return node;
		}
	}
	this.remove =key=>{
		root = removeNode(root,key);
	}
}
let nodes =[8,3,10,1,6,14,4,7,13];
let binaryTree = new BinaryTree();
nodes.forEach(key=>{
	binaryTree.insert(key);
})
let callback=key=>{
	console.log(key)
}
binaryTree.inOrderTraverse(callback);
binaryTree.preOrderTraverse(callback);
binaryTree.postOrderTraverse(callback);
console.log(`二叉树最小值：${binaryTree.min()}`)
console.log(`二叉树最大值：${binaryTree.max()}`)
console.log(`7是否在二叉树中：${binaryTree.search(7)}`)
console.log(`9是否在二叉树中：${binaryTree.search(9)}`)
binaryTree.remove(3);