前言
我们之前了解了 数组 / 栈 / 队列 / 链表，现在就来了解点稍微复杂点的～～
数据结构 - 树
树的数据结构就像我们生活中的真实的树，只不过是倒过来的形状。
树的前置知识
在了解树之前我们需要知道一些专业名词：
- 节点：树中的每个元素称为节点，如 A、B、C、D、E、F、G、H、I、J。
- 父节点：指向子节点的节点，如 A。
- 子节点：被父节点指向的节点，如 A 的孩子 B、C、D。
- 父子关系：相邻两节点的连线，称为父子关系，如 A 与 B，C 与 H，D 与 J。
- 根节点：没有父节点的节点，如 A。
- 叶子节点：没有子节点的节点，如 E、F、G、H、I、J。
- 兄弟节点：具有相同父节点的多个节点称为兄弟节点，如 B、C、D。
- 节点的高度：节点到叶子节点的最长路径所包含的边数。
- 节点的深度：根节点到节点的路径所包含的边数。
- 节点层数：节点的深度 +1（根节点的层数是 1 ）。
- 树的高度：等于根节点的高度。
- 森林： n 棵互不相交的树的集合。
从上图我们可以很清晰的知道：
高度是从下往上度量，比如一个人的身高 180cm ，起点就是从 0 开始的。
深度是从上往下度量，比如泳池的深度 180cm ，起点也是从 0 开始的。
高度和深度是带有度字的，都是从 0 开始计数的。
而层数的计算，是和我们平时的楼层的计算是一样的，最底下那层是第 1 层，是从 1 开始计数的，所以根节点位于第 1 层，其他子节点依次加 1。
二叉树分类 - 二叉树
定义
每个节点最多只有 2 个子节点的树，这两个节点分别是左子节点和右子节点，二叉树并不要求每个节点都有两个子节点，有的节点只有左子节点，有的节点只有右子节点。
二叉树分类 - 满二叉树
定义
一种特殊的二叉树，除了叶子节点外，每个节点都有左右两个子节点，这种二叉树叫做满二叉树。
二叉树分类 - 完全二叉树
定义
一种特殊的二叉树，叶子节点都在最底下两层，最后一层叶子节都靠左排列，并且除了最后一层，其他层的节点个数都要达到最大，这种二叉树叫做完全二叉树。
完全二叉树与不是完全二叉树的区分比较难，所以对比下图看看。
堆
堆其实是一种特殊的树。只要满足以下两点，它就是一个堆:
- 堆是一个完全二叉树 —— 完全二叉树：除了最后一层，其他层的节点个数都是满的，最后一层的节点都靠左排列。
- 堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值。 —— 也可以说：堆中每个节点的值都大于等于（或者小于等于）其左右子节点的值。这两种表述是等价的。
二叉树的实现和遍历
** 实现 **
二叉树主要有以下几种方法：
- insert(key)：向树中插入一个新的键。
- search(key)：在树中查找一个键，如果节点存在，则返回 true；如果不存在，则返回 false。
- min：返回树中最小的值/键。
- max：返回树中最大的值/键。
- remove(key)：从树中移除某个键。
3 种遍历方式：
-
前序遍历（根 => 左 => 右） —— 对于树中的任意节点来说，先访问这个节点，然后再访问它的左子树，最后访问它的右子树。
-
中序遍历（左 => 根 => 右） —— 对于树中的任意节点来说，先访问它的左子树，然后再访问它的本身，最后访问它的右子树。
-
后序遍历（左 => 右 => 根） —— 对于树中的任意节点来说，先访问它的左子树，然后再访问它的右子树，最后访问它本身。
- preOrderTraverse：通过先序遍历方式遍历所有节点。
- inOrderTraverse：通过中序遍历方式遍历所有节点。
- postOrderTraverse：通过后序遍历方式遍历所有节点。
增删查改
function BinarySearchTree() {
// 用于实例化节点的类
let Node = function (key) {
this.key = key; // 节点的键值
this.left = null; // 左节点的指针
this.right = null; // 右节点的指针
};
let root = null; // 将根节点置为null
this.insert = function (key) {
let newNode = new Node(key); // 实例化一个节点
if (root === null) {
root = newNode; // 如果是个空数，直接将该节点作为根节点
} else {
insertNode(root, newNode); // 插入节点（传入根节点作为参数）
}
};
let insertNode = function (node, newNode) {
// 如果插入节点的键值小于当前节点的键值
// 第一次执行insertNode函数时，当前节点就是根节点
if (newNode.key < node.key) {
if (node.left === null) {
// 如果当前节点的左子节点为空，就直接在该左子节点处插入
node.left = newNode;
} else {
// 如果左子节点不为空，需要继续执行insertNode函数
// 将要插入的节点于左子节点的后代继续比较，知道找到可以插入的位置
insertNode(node.left, newNode);
}
} else {
// 如果插入节点的键值大于当前节点的键值
// 处理过程类似，只是inserNode函数继续比较的是右子节点
if (node.right === null) {
node.right = newNode;
} else {
insertNode(node.right, newNode);
}
}
};
// 搜索最小值
// 在二叉搜索树里，不管是整个树还是其子树，最小值一定在树最左侧的最底层。
// 因此给定一颗树或其子树，只需要一直向左节点遍历到底就行了。
this.min = function (node) {
node = node || root;
// 一直遍历左侧子节点，直到底部
while (node && node.left !== null) {
node = node.left;
}
return node;
};
// 搜索最大值 - 搜索最大值与搜索最小值类似，只是沿着树的右侧遍历。
this.max = function (node) {
node = node || root;
while (node && node.right !== null) {
node = node.right;
}
return node;
};
// 搜索特定值
// 搜索特定值的处理与插入值的处理类似。
// 遍历树，将要搜索的值与遍历到的节点比较，如果前者大于后者，则递归遍历右侧子节点，反之，则递归遍历左侧子节点。
this.search = function (key, node) {
node = node || root;
return searchNode(key, node);
};
let searchNode = function (key, node) {
// 如果node === null，说明树中没有要查找的值，返回false
if (node === null) {
return false;
}
if (key < node.key) {
// 如果要查找的值小于该节点，继续递归遍历其左侧节点
return searchNode(key, node.left);
} else if (key > node.key) {
// 如果要查找的值大于该节点，继续递归遍历其右侧节点
return searchNode(key, node.right);
} else {
// 如果要查找的值等于该节点，说明查找成功，返回改节点
return node;
}
};
// 移除节点 - 首先要在树中查找到要移除的节点，再判断该节点是否有子节点、有一个子节点或者有两个子节点，最后分别处理。
this.remove = function (key, node) {
node = node || root;
return removeNode(key, node);
};
let self = this;
let removeNode = function (key, node) {
// 如果node === null，说明树中没有要查找的值，返回false
if (node === null) {
return false;
}
// 找到要删除的节点
node = self.search(key, node);
// 第一种情况，该节点没有子节点
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 = self.min(node.right);
// 替换
node.key = aux.key;
// 删除最小值
node.right = removeNode(aux.key, node.right);
return node;
// 当要删除的节点有两个子节点时，为了不破坏树的结构，
// 删除后要替补上来的节点的键值大小必须在已删除节点的左、右子节点的键值之间，且替补上来的节点不应该有子节点，否则会产生一个节点有多个字节点的情况，因此，找右侧子树的最小值替换上来。
// 同理，找左侧子树的最大值替换上来也可以。
};
第三种情况的处理过程，如下图所示：
先序遍历
// 先序遍历
this.preOrderTraverse = (callback) => {
// 同样的，callback用于对遍历到的节点做操作
preOrderTraverseNode(root, callback);
};
let preOrderTraverseNode = function (node, callback) {
// 遍历到node为null为止
if (node !== null) {
callback(node.key); // 先处理当前节点
preOrderTraverseNode(node.left, callback); // 再继续遍历左子节点
preOrderTraverseNode(node.right, callback); // 最后遍历右子节点
}
};
先序：
中序遍历
// 中序遍历
this.inOrderTraverse = function (callback) {
inOrderTraverseNode = (root, callback);
};
let inOrderTraverseNode = function (node, callback) {
// 遍历到node === null 为止
if (node !== null) {
// 先遍历左子节点
inOrderTraverseNode(node.left, callback);
callback(node.key); // 处理当前节点
// 最后遍历右子节点
inOrderTraverseNode(node.right, callback);
}
};
中序：
后序遍历
// 后序遍历
this.postOrderTraverse = function (callback) {
postOrderTraverseNode = (root, callback);
};
let postOrderTraverseNode = function (node, callback) {
// 遍历到node === null 为止
if (node !== null) {
// 先遍历左子节点
inOrderTraverseNode(node.left, callback);
// 遍历右子节点
inOrderTraverseNode(node.right, callback);
callback(node.key); // 最后处理当前节点
}
};
后序：
// 打印
this.print = function () {
console.log('root :', root);
return root;
};
}
// 测试
let binarySearchTree = new BinarySearchTree();
let arr = [11, 7, 5, 3, 6, 9, 8, 10, 15, 13, 12, 14, 20, 18, 25];
for (let i = 0; i < arr.length; i++) {
let value = arr[i];
binarySearchTree.insert(value);
}
console.log('先序遍历：');
let arr = [];
binarySearchTree.preOrderTraverse(function (value) {
arr.push(value);
});
console.log('arr :', arr); // [11, 7, 5, 3, 6, 9, 8, 10, 15, 13, 12, 14, 20, 18, 25]
let min = binarySearchTree.min();
console.log('min:', min); // 3
let max = binarySearchTree.max();
console.log('max:', max); // 25
let search = binarySearchTree.search(10);
console.log('search:', search); // 10
let remove = binarySearchTree.remove(13);
console.log('remove:', remove); // 13
console.log('先序遍历：');
let arr1 = [];
binarySearchTree.preOrderTraverse(function (value) {
arr1.push(value);
});
console.log('arr1 :', arr1); // [11, 7, 5, 3, 6, 9, 8, 10, 15, 14, 12, 20, 18, 25]
console.log('中序遍历：');
let arr2 = [];
binarySearchTree.inOrderTraverse(function (value) {
arr2.push(value);
});
console.log('arr2 :', arr2); // [3, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 18, 20, 25]
console.log('后序遍历：');
let arr3 = [];
binarySearchTree.postOrderTraverse(function (value) {
arr3.push(value);
});
console.log('arr3 :', arr3); // [3, 6, 5, 8, 10, 9, 7, 12, 14, 18, 25, 20, 15, 11]
binarySearchTree.print(); // 看控制台
