本文会针对树这种数据结构，进行相关内容的阐述。其实本文应该算是一篇读书笔记。
文章首发于我的个人博客网站：https://blog.fstars.wang/posts/alg-tree-analy-in-js/
内容总览
- 树
- 二叉树
- 二叉查找树
- 堆和堆的一些操作
- 堆排序
- 堆的应用
另外，我先在这里给出 js 实现的源码地址：
树
这里简单说下树是什么。
树是一种非线性的数据结构。树中的元素称为“节点”。每个节点有有限个子节点或没有子节点，且树中不能有环路。
两个相连的节点的关系称为 “父子关系”。
一些术语（摘自维基百科）：
- 节点的度：一个节点含有的子树的个数称为该节点的度；
- 树的度：一棵树中，最大的节点的度称为树的度；
- 叶节点或终端节点：度为零的节点；
- 非终端节点或分支节点：度不为零的节点；
- 父亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
- 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
- 兄弟节点：具有相同父节点的节点互称为兄弟节点；
- 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
- 深度：对于任意节点n，n的深度为从根到n的唯一路径长，根的深度为0；
- 高度：对于任意节点n，n的高度为从n到一片树叶的最长路径长，所有树叶的高度为0；
- 堂兄弟节点：父节点在同一层的节点互为堂兄弟；
- 节点的祖先：从根到该节点所经分支上的所有节点；
- 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
- 森林：由m（m>=0）棵互不相交的树的集合称为森林；
二叉树
树有很多种类，比如二叉树、三叉树、四叉树等。但最常用的树就是二叉树。
二叉树是每个节点最多只有两个分支的树结构，这两个分支的节点被称为 左子节点 和 右子节点。
满二叉树，指的是除了叶子节点，每个节点都有两个子节点的二叉树。
完全二叉树：除了最后一层，其他层的节点个数都要最大，且最后一层的节点都靠左排列的二叉树。
可能有人觉得完全二叉树看起来好像没什么用，怎么还靠左边的，靠中间不行吗？其实靠左是因为二叉树的其中一种数据存储方式是用数组存储，使用完全二叉树就不会浪费数组的空间（不会出现一些数组元素不存储的情况）
二叉树的存储
1. 链式存储法
链式存储法，是通过指针的方式来记录父子关系的一种方法。它有点类似链表，每个节点除了保存自身的数据外，还会有left 和 right 两个指针，指向另外两个节点。
const node = {
data: 1, // 节点保存的数据
left: node2, // 左子节点指向 node2 节点
right: null // null 表示没有右子节点
}
2. 顺序存储法
用数组存储。为了代码可读性更好，我们一般会选择浪费数组下标为 0 的存储位置，即根节点在下标为 1 的位置。 这时父节点和左右节点的下标关系如下：
left = 2 * i;
right = 2 * i + 1;
i = left / 2;
i = right / 2; // 这里是向下取整
这里的 i 为父节点下标，left 和 right 为两个子节点下标。
这里有个要注意的地方：这里的父节点的下标值是子节点除以 2 并 取整。（有些编程语言的整数相除，会自动将得到的结果去掉小数部分，而一些编程语言，比如 Javascript，是会得到小数的，需要手动向下取整。）
如果你就是不想浪费数组的第一个元素的存储位置，誓要将根节点保存在数组的第一个位置。那此时父节点和子节点的下标关系为：
left = 2 * i + 1;
right = 2 * i + 2;
i = (left - 1) / 2;
i = (right - 1) / 2;
如果某棵二叉树是一棵完全二叉树，那用数组存储无疑是最节省内存的一种方式。
二叉树的遍历
这个是很常见的面试题呢。
1. 前序遍历
根左右。 这里的“前”描述的是根节点，即根节点最先输出（打印），然后输出左子树，最后输出右子树。
代码中的树是用 链式存储法 存储的。代码实现用到了 递归。
// 前序遍历（根左右）
preOrder() {
let order = '';
r(this.root);
order = order.slice(0, order.length - 1); // 这里只是去掉最后的一个逗号。
return order;
// 递归函数
function r(node) {
if (!node) return;
order += `${node.val},`;
r(node.left);
r(node.right);
}
},
2. 中序遍历
左根右。 “中序”的这个“中”也是指的根节点的输出位置是中间。中序遍历先输出左子树，再输出根节点，最后输出右子树。
// 中序遍历
inOrder() {
let order = '';
r(this.root);
order = order.slice(0, order.length - 1);
return order;
// 递归函数
function r(node) {
if (!node) return;
r(node.left);
order += `${node.val},`;
r(node.right);
}
},
3. 后续遍历
左右根。 先打印左子树，然后打印根节点，最后打印右子树。
postOrder() {
let order = '';
r(this.root);
order = order.slice(0, order.length - 1);
return order;
// 递归函数
function r(node) {
if (!node) return;
r(node.left);
r(node.right);
order += `${node.val},`;
}
},
4. 层次遍历
层次遍历，就是每层的节点从左往右遍历，直到遍历完所有节点。如果是顺序存储法存储的，数组从前往后遍历即可。如果是链式存储法存储树，实现就会复杂一些，要用到一个队列
levelOrder() {
if (this.root == null) return '';
let a = [],
left, right;
a.push(this.root);
// 节点入队，指针指向头部元素，如果它有left/right，入队。
// 指针后移，继续同样步骤。。。直至指针跑到队列尾部后面去。。。
for(let i = 0; i < a.length; i++) { // 需要注意的是，数组 a 的长度是动态变化的（不停变长）
left = a[i].left;
if (left) a.push(left);
right = a[i].right;
if (right) a.push(right);
}
return a.map(item => item.val).join(',');
}
二叉查找树
二叉查找树，也叫做 二叉搜索树。此外它也被称为 二叉排序树，因为中序遍历就可以得到有序的数据序列（非常高效，时间复杂度是 O(n)）。
二叉查找树的作用是快速查找。除了快速查找，它也支持快速插入、删除数据。
那么什么样的二叉树才是二叉查找树呢？二叉查找树是任意一个节点的左子树的节点都小于该节点，任意一个节点的的右子树的节点都大于该节点的二叉树。
根据定义，二叉查找树是 不允许有两个数据相同的节点的。
二叉查找树的查找操作
先和根节点的值比较，如果相等，就找到了；如果要查找的值比根节点小，就在左子树中递归查找；如果比根节点大，就在右子树中递归查找。
find(val) {
// 假设二叉树没有重复数据
let p = this.root;
while(p != null) {
if (val == p.val) return p;
else if (val < p.val) p = p.left;
else p = p.right;
}
return null; // 没找到
},
二叉查找树的插入操作
类似查找操作。从根节点开始，比较要插入的数据和节点的大小关系。如果要插入的数据比当前节点的数据大，且右子树为空，就作为该节点的右子节点；如果右子树不为空，就继续递归右子树。同理，比当前节点数据小，就看该节点的左子树，若为空，插入到左子节点位置；若不为空，就递归左子树。
// 插入节点
insert(val) {
if (this.root == null) {
this.root = node;
return true;
}
let node = new Node(val);
let p = this.root;
while (p != null) {
if (val < p.val) {
if (p.left == null) {
p.left = node;
return this.inOrder();
// 返回个中序遍历的结果，检查插入是否正确。（你可以改为 true，表示插入成功）
}
p = p.left;
}
else if (val > p.val) {
// preP = p;
if (p.right == null) {
p.right = node;
return this.inOrder();
}
p = p.right;
}
if (val == p.val) {
console.warn('二叉树中含相同值的数据，无法插入')
return false;
}
}
},
二叉查找树的删除操作
这个就很复杂，要分三种情况：
- 要删除的节点没有子节点：直接更新父节点指向其的指针为 null
- 要删除的节点只有一个子节点：父节点中指向要删除的节点的指针，更新为要删除节点的那个子节点。
- 要删除的节点有两个子节点：找到右子树中的最小节点（一般是叶子节点），替换到要删除的节点上。（当然你也可以选择找左子树的最大节点）
// 删除
remove(val) {
// 假设二叉树没有重复数据
let p = this.root;
let parent, dir; // 暂不考虑只有根节点一个的情况。
while(p != null) {
if (val == p.val) {
// 要删除的节点没有子节点
if (p.left == null && p.right == null) {
parent[dir] = null;
return true;
}
// 要删除的节点只有一个子节点
else if (p.left == null && p.right != null) {
parent[dir] = p.right
console.log('只有右节点');
return true;
} else if (p.right == null && p.left != null) {
parent[dir] = p.left;
console.log('只有左节点');
return true;
}
// 要删除的节点有两个子节点
// 可以将右子树的最小结点替换到被删除的节点位置，并删除这个最小节点
// 当然你也可以在左子树中找最大节点。
else if (p.left != null && p.right != null) {
// 因为要记录最小节点的父节点，所以不能用 this.findMin()
// 第一步：找出最小节点 minP
let minParent,
minP = p;
while (minP) {
if (minP.left == null) {
// 找到。
break;
// return minP;
}
minParent = minP;
minP = minP.left;
}
// 第二步：替换（把数据转移过去即可）
p.val = minP.val;
// 第三步：删除最小节点
if (minP.right == null) {
minParent.left = null;
console.log('最小节点没有子节点');
return true;
} else if (minP.right != null) {
minParent.left = minP.right;
console.log('最小节点只有右节点');
return true;
}
}
return p;
}
// 继续找要删除的节点。
else {
parent = p;
if (val < p.val) {
p = p.left;
dir = 'left';
} else {
p = p.right;
dir = 'right';
}
}
}
return null; // 没找到
// 要保存父节点，且要记录当前节点是父节点的 left 还是 right。
},
还有另一种简单的删除操作，就是标记一个节点为“已删除”，虽然操作变得简单了，但“已删除”的数据仍然在内存中，会浪费内存空间。
支持重复数据的二叉查找树
一般来说，根据定义，二叉查找树是不允许有重复数据的。但实际开发中，数据一般不可能不重复。所以我们看看怎么使二叉查找树支持重复数据存储：
- 节点改为可以存储多个数据，而不是只有一个数据。可以考虑链表和动态扩容数组。
- 插入过程中，如果发现已经有重复的数据了，就放到这个节点的右子树的最左节点的位置（当然你也可以考虑放到左子树的最右边节点位置）。如果是这样的实现的话，查找操作和删除操作就要跟着做一些小修改。
平衡二叉树
维基百科的定义：平衡二叉搜索树（英语：Balanced Binary Tree）是一种结构平衡的二叉搜索树，即叶节点高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。它能在O(logn)内完成插入、查找和删除操作，最早被发明的平衡二叉搜索树为AVL树。
平衡二叉树的发明，是为了解决二叉树在不断插入、删除等动态操作后，导致时间复杂度退化的问题。它会让二叉树尽量地保持平衡，即保持 矮矮胖胖* 的样子。
平衡二叉树中，最为有名的就是 红黑树 了。是不是经常有群友开玩笑说他们招人，要求当场手写红黑树呢。红黑树的性能很好，广泛用于实际开发中，其他的平衡二叉树则很少出现在人们的视野之中。
平衡二叉树的实现很复杂，就暂时不详细分析了。
堆
堆是一个 每个节点的数据都大于等于（或小于等于）它的子节点的完全二叉树。
对于每个节点的值都大于等于子树中每个节点值的堆，我们叫作 大顶堆。对于每个节点的值都小于等于子树中每个节点值的堆，我们叫作 小顶堆。
因为堆是完全二叉树，所以我们用数组存储。
1. 插入一个元素
插入元素到堆，具体做法是插入到数组的末尾，然后通过 堆化 操作，对树进行调整，重新变成堆。
堆化（heapify），是指一个节点，不停地向上或向下进行交换，直到找到合适的位置，使当前的二叉树变成堆。
插入时进行的堆化是 从下往上堆化。新插入的元素位于末尾，需要不停地和父元素进行比较和进行交换，直到找到合适的位置结束，此时树就会又变成堆。
// 入堆，从下往上堆化。
insert(val) {
// count 指的是当前数组存储数据的大小，n 为 数组的容量
//（当然js的数组是动态数组。这里的 n 是我手动加的限制）
if (this.count >= this.n) {
console.log('堆满了，别加了！！')
return;
}
this.count++;
let a = this.a; // a 是存储数据的数组
a[this.count] = val;
let i = this.count,
j = Math.floor(i/2); // 临时存储 i/2
while (i > 1 && a[i] > a[j]) {
[a[i], a[j]] = [a[j], a[i]];
i = j;
j = Math.floor(i/2);
}
return true;
}
2. 删除堆顶元素
删除了堆顶元素后，我们需要把最后一个元素移动到堆顶元素位置，然后进行 从上往下的堆化。
从上往下堆化具体的实现是：最后一个元素替换掉堆顶元素后，就比较堆顶元素和它的两个子节点，看看谁最大，如果不是堆顶元素最大，堆顶元素就和值最大的子节点交换。重复上面的步骤，直到当前节点最大或者当前节点成为叶子节点（到底了）。
// 删除堆顶元素
removeMax() {
if (this.count == 0) return false; // 堆为空
this.a[1] = this.a[this.count];
this.a[this.count] = undefined;
this.count--;
// 从上往下 堆化
let i = 1,
maxPos = i;
while (true) {
if (i * 2 <= this.count && this.a[i*2] > this.a[maxPos]) maxPos = i * 2;
if (i * 2 + 1 <= this.count && this.a[i*2 + 1] > this.a[maxPos]) maxPos = i * 2 + 1;
if (maxPos == i) {
break;
}
[this.a[i], this.a[maxPos]] = [this.a[maxPos], this.a[i]];
i = maxPos;
}
return true;
}
堆排序
堆排序算法分两个步骤：先建堆，然后进行排序。
1. 建堆
对数组进行 原地 建堆。原地是指在原数组上进行操作，不需要另开一个堆。
建堆的方式有两种：
- 借助前面提到的插入操作的方式。
这里就是往 “堆区域” 末尾插入元素，然后从下往上堆化。类似插入排序，我们将数组分为 “堆区域” 和 “未处理区域”，不停地将“未处理区域”里的元素插入到“堆区域” 中，直到遍历完整个数组。
- 从最后一个非叶子节点开始往前，进行 从上往下的堆化。
叶子节点因为没有子节点，所以不需要进行堆化。另外，对于完全二叉树来说，最后一个非叶子节点的下标为 i / 2（i 从1开始，你可以自己画个完全二叉树验证一下）。
建堆的复杂度是 O(n)。
2. 排序
将堆顶节点和最后一个节点进行交换，然后对剩余的 n -1 个元素进行从上往下堆化。然后我们再交换堆顶节点和第 n - 1 个元素，然后对剩余的 n - 2 个元素进行从上往下堆化，就这样不停地交换和堆化，直到堆中只有一个元素。
性能分析
1. 堆排序的时间复杂度是 O(nlogn)。
建堆的时间复杂度是 O(n)，排序过程的时间复杂度是 O(nlogn)，所以堆排序的时间复杂度是 O(nlogn)。
2. 堆排序是不稳定的排序
因为排序过程中，堆顶元素会和堆的最后一个元素进行交换，导致排序不稳定。
3. 堆排序是原地排序
堆排序和快速排序的比较
快速排序比堆排序好。理由如下：
- 堆排序访问数据方式不好，是跳着访问数组元素的，不利于 CPU缓存。
- 堆排序的交换操作更多。堆排序的建堆完成后，会降低数据的有序堆，这样会使得交换操作变多。
代码实现是在原数组上进行数据交换的。
堆的应用
1. 优先级队列
优先级可以用于解决 合并有序小文件、高性能定时器 等问题。
2. 求 TopK 数据
这个就是维护一个大小为 k 的小顶堆。将未入堆的元素和堆顶元素比较，如果比堆顶元素大，就入堆，直到所有元素都入堆后，这个堆就是 TopK 元素了。
时间复杂度是 O(nlogK)。最坏情况下，一次堆化需要 O(logK)，要进行 n 次堆化操作。
3. 求中位数
如果是静态数据，先排序，然后求中位数即可，这样边际成本低。
如果是动态数据，那就需要维护一个 大顶堆 和一个小顶堆。要求大顶堆的数量等于小顶堆的数量或小顶堆的数量+1，且大顶堆的元素都小于小顶堆的元素。中位数即大顶堆的堆顶元素。
初始化的时候，可以用类似 topK 算法，弄一个数量为 k 为 n/2 的小顶堆放数组右边，然后将剩余的元素转换为大顶堆。
然后每次添加数据的时候，都会分别比较大顶堆的堆顶元素和小顶堆的堆顶元素，决定插入到哪边。插入后，还要进行一些堆的插入和删除操作，以维持这两个堆数量要差不多相同（左右元素数量相同或者左边堆比右边多一个）。
除了可以利用堆求中位数，我们还可以利用堆计算 “99% 响应时间” 的问题。即维护数量为 99/n 的大顶堆和数量为 1/n 的小顶堆。
