刚开始学编程，都知道数据结构和算法是很重要的，特别是二叉树，一起来了解下
二叉树
二叉树是一种非常重要的[数据结构]，非常多其他数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们寻常所说的层次遍历。由于树的定义本身就是递归定义，因此採用递归的方法去实现树的三种遍历不仅easy理解并且代码非常简洁，而对于广度遍历来说，须要其他数据结构的支撑。比方堆了。所以。对于一段代码来说，可读性有时候要比代码本身的效率要重要的多。
四种基本的遍历思想为：
- 前序遍历：根结点 ---> 左子树 ---> 右子树
- 中序遍历：左子树---> 根结点 ---> 右子树
- 后序遍历：左子树 ---> 右子树 ---> 根结点
- 层次遍历：仅仅需按层次遍历就可以
图解二叉树遍历思想
前序遍历
先访问根节点，然后前序遍历左子树，再前序遍历右子树，（W）型 （中 左 右），如下图
前序.png
遍历顺序：ABDHIEJCFKG
中序遍历
从根节点开始（注意并不是先访问根节点），中序遍历根节点的左子树，然后是访问根节点，最后中序遍历根节点的右子树。（M）型，（左 中 右），如下图
中序.png
遍历顺序：HDIBEJAFKCG
后续遍历
从左到右先叶子后节点的方式遍历访问左右子树，最后访问根节点。（反W）逆时针型 （左 右 中），如下图
后续.png
遍历顺序：HIDJEBKFGCA
层序遍历
从树的第一层，也就是根节点开始访问，从上到下逐层遍历，在同一层中，按从左到右的顺序结点逐个访问。（E）型，如下图
层序.png
遍历顺序：ABCDEFGHIJK
二叉排序树
二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。
它具有以下特点：
（1）若左子树不空，则左子树上所有节点的值均小于它的[根节]点的值；
（2）若右子树不空，则右子树上所有节点的值均大于它的根节点的值；
（3）左、右子树也分别为二叉排序树；
（4）没有键值相等的节点。
下面通过js实现一棵二叉排序树：
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 nodes = [13,8,18,6,9,15,20,4,7,10,17]
var binaryTree = new BinaryTree()
nodes.forEach(function(key){
binaryTree.insert(key)
})
//console.log(binaryTree)
第一次插入的值将成为root节点，后面的值依次成为左右节点，最终形成如下树
binarySortTree.png
中序遍历
//中序遍历
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 callback = function(key) {
console.log(key)
}
binaryTree.inOrderTraverse(callback) //4,6,7,8,9,10,13,15,17,18,20
遍历结果：4,6,7,8,9,10,13,15,17,18,20
前序遍历
//前序遍历
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)
}
...
binaryTree.preOrderTraverse(callback) //13,8,6,4,7,9,10,18,15,17,20
遍历结果： 13,8,6,4,7,9,10,18,15,17,20
后序遍历
//后序遍历
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)
}
...
binaryTree.postOrderTraverse(callback) //4,7,6,10,9,8,17,15,20,18,13
遍历结果：4,7,6,10,9,8,17,15,20,18,13
查找节点
//查找最小值
var minNode = function(node){
if (node){
while(node && node.left !== null){
node = node.left
}
return node.key
}
return null
}
this.min = function(){
return minNode(root)
}
//查找最大值
var maxNode = function(node){
if (node){
while(node && node.right !== null){
node = node.right
}
return node.key
}
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)
}
......
console.log("min node:"+binaryTree.min()) //4
console.log("max node:"+binaryTree.max()) //20
console.log("search node:"+binaryTree.search(6)) //search node:true
删除节点
//删除节点//若当前节点无left节点则返回当前节点
var findMinNode = function(node){
if (node){
while(node && 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;//此时已删除节点node
return node;
} else if (node.right === null){
node = node.left
return node;
}
//有2个节点
var aux = findMinNode(node.right)
node.key = aux.key
node.right = removeNode(node.right, aux.key)
return node;
}
}
this.remove = function(key){
root = removeNode(root,key)
}
...
binaryTree.remove(6)
console.log("search node:"+binaryTree.search(6)) //search node:false
console.log("search node:"+binaryTree.search(4)) //search node:true
console.log("search node:"+binaryTree.search(7)) //search node:true
删除节点，分3种情况：
- 无子节点，直接删除
- 仅有单子节点，则将该子节点替换当前节点
- 有双子节点，找当前节点的右节点的最小子左节点来替换当前节点
