二叉树

var BinaryTree = function() {
	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 node = new Node(key);
		if (root === null) {
			root = node
		} else {
			insertNode(root, node);
		}
	}

	var inOrderTraverseNode = function(node, callback) { // 中序
		if (node !== null) {
			inOrderTraverseNode(node.left, callback);
			callback(node.key);
			inOrderTraverseNode(node.right, callback);
		}
	}
	this.inOrderTraverse = function(callback) {
		if (root !== null) {
			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 minNode = function(node) {
		if (node) {
			while (node.left !== null) { //最左
				node = node.left;
			}
			return node.key;
		} else {
			return null;
		}
	}
	this.min = function() {
		return minNode(root);
	}

	var maxNode = function(node) {
		if (node) {
			while (node.right !== null) {
				node = node.right;
			}
			return node.key;
		} else {
			return null;
		}
	}
	this.max = function() {
		return maxNode(root);
	}

	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);
	}
	var findMinNode = function(node) {
		if (node) {
			while (node.left !== null) {
				node = node.left;
			}
			return node;
		}
		return null;
	}
	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);
			return node;
		} 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;
			} else { // 含有两个孩子
				var aux = findMinNode(node.right);
				node.key = aux.key;
				node.right = removeNode(node.right, aux.key);
				return node;
			}
		}
	}
	this.remove = function(key) {
		return removeNode(root, key);
	}

}
var callback = function(key) {
	console.log(key);
}
var nodes = [8,3,10,1,6,14,4,7,13];
var binaryTree = new BinaryTree();
nodes.forEach(function(key) {
	binaryTree.insert(key);
})
//binaryTree.inOrderTraverse(callback);
//binaryTree.preOrderTraverse(callback);
//console.log('min is: ' + binaryTree.min());
//console.log('max is: ' + binaryTree.max());
//console.log(binaryTree.search(7));
//console.log(binaryTree.search(9));
console.log(binaryTree.remove(10));
binaryTree.inOrderTraverse(callback);