平衡二叉树，B树
AVL树（平衡二叉树）
AVL树本质上是一颗二叉查找树，但是它又具有以下特点：
1、 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1
2、 左右两个子树都是一棵平衡二叉树。
AVL树解决了普通二叉查找树演化为线性导致线性查找时间问题
AVL树平衡的操作主要有：
1、左-左型：做右旋。
2、右-右型：做左旋转。
3、左-右型：先做左旋，后做右旋。
4、右-左型：先做右旋，再做左旋。
右旋：把左孩子变成父节点，原来的父节点变成左孩子的右孩子，见下图（左左型）。
左旋：把右孩子变成父节点，原来的父节点变成右孩子的左孩子，见下图（右右型）。
下面是右左型的平衡操作
实现代码（没有编写测试用例，可能会有一些边界未处理问题）
public class AVL { public class AVLNode{ int height; AVLNode leftChild; AVLNode rightChild; AVLNode parent; int value; } public int getHeight(AVLNode node) { if (node == null) { return 0; }else { return node.height; } } /** * 左左型不平衡，进行右旋操作 * @param LL_type_node */ public void R_Rotate(AVLNode LL_type_node) { if (LL_type_node != null) { AVLNode left = LL_type_node.leftChild; // 取出要旋转节点的左孩子 AVLNode parent = LL_type_node.parent; // 取出要旋转节点的父节点 LL_type_node.leftChild = left.rightChild; // 左孩子的右孩子变成父节点的左孩子 left.rightChild.parent = LL_type_node; left.rightChild = LL_type_node; // 左孩子的右节点变为其原来的父节点 // 更新父节点 LL_type_node.parent = left; left.parent = parent; // 检查原来要旋转节点是其父节点的左孩子还是右孩子 if (parent.leftChild == LL_type_node) { parent.leftChild = left; }else if (parent.rightChild == LL_type_node) { parent.rightChild = left; } LL_type_node.height = Math.max(getHeight(LL_type_node.leftChild), getHeight(LL_type_node.rightChild)) + 1; left.height = Math.max(getHeight(left.leftChild), getHeight(left.rightChild)) + 1; parent.height = Math.max(getHeight(parent.leftChild), getHeight(parent.rightChild)) + 1; } } /** * 右右型不平衡，进行左旋操作 * @param LL_type_node */ public void L_Rotate(AVLNode RR_type_node) { if (RR_type_node != null) { AVLNode right = RR_type_node.leftChild; // 取出要旋转节点的右孩子 AVLNode parent = RR_type_node.parent; // 取出要旋转节点的父节点 RR_type_node.rightChild = right.leftChild; // 右孩子的左孩子变成父节点的右孩子 right.leftChild.parent = RR_type_node; right.leftChild = RR_type_node; // 左孩子的右节点变为其原来的父节点 // 更新父节点 RR_type_node.parent = right; right.parent = parent; // 检查原来要旋转节点是其父节点的左孩子还是右孩子 if (parent.leftChild == RR_type_node) { parent.leftChild = right; }else if (parent.rightChild == RR_type_node) { parent.rightChild = right; } RR_type_node.height = Math.max(getHeight(RR_type_node.leftChild), getHeight(RR_type_node.rightChild)) + 1; right.height = Math.max(getHeight(right.leftChild), getHeight(right.rightChild)) + 1; parent.height = Math.max(getHeight(parent.leftChild), getHeight(parent.rightChild)) + 1; } } /** * 左右型，先左旋，后右旋 * @param LR_type_node */ public void L_R_Rotate(AVLNode LR_type_node) { if (LR_type_node != null) { L_Rotate(LR_type_node.leftChild); R_Rotate(LR_type_node); } } /** * 左右型，先右旋，后左旋 * @param LR_type_node */ public void R_L_Rotate(AVLNode RL_type_node) { if (RL_type_node != null) { R_Rotate(RL_type_node.rightChild); L_Rotate(RL_type_node); } } public AVLNode insertAVLTree(AVLNode root, AVLNode toInsert) { AVLNode rtRoot = root; if (toInsert != null) { if (root != null) { if (root.value > toInsert.value) { rtRoot.leftChild = insertAVLTree(root.leftChild, toInsert); //插入后看看是否需要调整 if (getHeight(rtRoot.leftChild) - getHeight(rtRoot.rightChild) == 2) { // 左左型，进行右旋 if (toInsert.value < rtRoot.leftChild.value) { R_Rotate(rtRoot); }else { // 左右型 L_R_Rotate(rtRoot); } } }else if (root.value < toInsert.value) { rtRoot.rightChild = insertAVLTree(root.rightChild, toInsert); //插入后看看是否需要调整 if (getHeight(rtRoot.rightChild) - getHeight(rtRoot.leftChild) == 2) { // 右右型，进行左旋 if (toInsert.value > rtRoot.rightChild.value) { L_Rotate(rtRoot); }else { // 右左型 R_L_Rotate(rtRoot); } } } }else { rtRoot = toInsert; } } rtRoot.height = Math.max(getHeight(rtRoot.leftChild), getHeight(rtRoot.rightChild)) + 1; return rtRoot; } public void deleteNode(AVLNode root, int value) { if (root != null) { if (value < root.value) { deleteNode(root.leftChild, value); int lh = getHeight(root.leftChild); int rh = getHeight(root.rightChild); if (rh - lh == 2) { if(getHeight(root.rightChild.rightChild) > getHeight(root.rightChild.leftChild)){ // 右右型 L_Rotate(root); }else{ // 右左型 R_L_Rotate(root); } } }else if (value > root.value) { deleteNode(root.rightChild, value); int lh = getHeight(root.leftChild); int rh = getHeight(root.rightChild); if (lh - rh == 2) { if(getHeight(root.leftChild.leftChild) > getHeight(root.leftChild.rightChild)){ // 左左型 R_Rotate(root); }else{ // 左右型 L_R_Rotate(root); } } }else { AVLNode toDeleteParent = root.parent; if (root.leftChild == null) { /* 要删除节点的左子树为空，那么该节点可以直接删除而不用找后继节点（因为后继就是它的右 * 孩子，如果它的右孩子也为空，那说明它是个叶子节点，可直接删） */ if (root == toDeleteParent.leftChild) { toDeleteParent.leftChild = root.rightChild; if (toDeleteParent.leftChild != null) { toDeleteParent.leftChild.parent = toDeleteParent; } }else { toDeleteParent.rightChild = root.rightChild; if (toDeleteParent.rightChild != null) { toDeleteParent.rightChild.parent = toDeleteParent; } } }else if (root.rightChild == null) { /* 要删除节点的右子树为空，那么该节点可以直接删除而不用找后继节点（因为后继就是它的父 * 节点，如果它的左孩子也为空，那说明它是个叶子节点，可直接删） */ if (root == toDeleteParent.leftChild) { toDeleteParent.leftChild = root.leftChild; if (toDeleteParent.leftChild != null) { toDeleteParent.leftChild.parent = toDeleteParent; } }else { toDeleteParent.rightChild = root.leftChild; if (toDeleteParent.rightChild != null) { toDeleteParent.rightChild.parent = toDeleteParent; } } }else { int next = getHeight(root); root.value = next; // 用后继代替待删除节点 deleteNode(root.rightChild, next); // 删除后继 int lh = getHeight(root.leftChild); int rh = getHeight(root.rightChild); if (lh - rh == 2) { if(getHeight(root.leftChild.leftChild) > getHeight(root.leftChild.rightChild)){ // 左左型 R_Rotate(root); }else{ // 左右型 L_R_Rotate(root); } } } } root.height = Math.max(getHeight(root.leftChild), getHeight(root.leftChild)) + 1; } } /** * 取得当前节点的后继 * @param currentNode * @return */ public int getNextNodeValue(AVLNode currentNode) { if ((currentNode = currentNode.rightChild) != null) { while(currentNode.leftChild != null){ currentNode = currentNode.leftChild; } } return currentNode.value; } }
红黑树
红黑树是近似平衡的二叉查找树，它相比AVL树在调整的时候可以减少旋转次数，它具有以下特点
1、节点是红色或黑色。
2、根节点是黑色。
3、每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
4、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。
红黑树的插入删除过程较为复杂，详细请参考以下博客
红黑树插入：https://www.cnblogs.com/CarpenterLee/p/5503882.html
红黑树删除：https://www.cnblogs.com/CarpenterLee/p/5525688.html
B树
一棵m阶B树(balanced tree of order m)是一棵平衡的m路搜索树。它或者是空树，或者是满足下列性质的树：
1、根结点至少有两个子女；
2、每个非根节点所包含的关键字个数 j 满足：┌m/2┐ - 1 <= j <= m - 1；即每个节点最多有m棵子树（至于为什么去m/2的上界，我的理解应该是为了树的平衡性质以及树的高度不会太高）
3、除根结点以外的所有结点（不包括叶子结点）的度数正好是关键字总数加1，故内部子树个数 k 满足：┌m/2┐ <= k <= m ；
4、所有的叶子结点都位于同一层。
下图是一棵4阶B树（指针域未画出来），4阶指的是某个节点最多有4棵子树。
B树节点的插入：往上图的4阶B树插入关键字6。插入6，进入根节点的左子树，找到合适位置插入，此时关键字6所在的节点包含 {5, 6, 8, 9} 共NUM = 4个关键字，不满足4阶B树性质（最多有4-1个关键字），进行分裂，分裂点为 NUM / 2向上取整，故在关键字6，插入后的结果为见下图。插入操作要注意的就是分裂的关键字是作为新的节点，加入其父节点中，然后判断此时父节点是否需要分裂。
B树节点的删除：
相比B树的插入稍微复杂一些，当从B-树中删除一个关键字Ki时，总的分为以下两种情况：
如果该关键字所在的结点不是最下层的非叶子结点，则先需要把此关键字与它在B树中后继对换位置，即以指针Pi所指子树中的最小关键字Y代替Ki，然后在相应的结点中删除Y。
如果该关键字所在的结点正好是最下层的非叶子结点，这种情况下，会有以下两种可能：
1、若该关键字Ki所在结点中的关键字个数不小于┌m/2┐，则可以直接从该结点中删除该关键字和相应指针即可。
2、若该关键字Ki所在结点中的关键字个数小于┌m/2┐，则直接从结点中删除关键字会导致此结点中所含关键字个数小于┌m/2┐-1 。这种情况下，需考察该结点在B树中的左或右兄弟结点，从兄弟结点中移若干个关键字到该结点中来（这也涉及它们的双亲结点中的一个关键字要作相应变化），使两个结点中所含关键字个数基本相同；但如果其兄弟结点的关键字个数也很少，刚好等于┌m/2┐-1 ，这种移动则不能进行，这种情形下，需要把删除了关键字Ki的结点、它的兄弟结点及它们双亲结点中的一个关键字合并为一个结点。能力有限，无法画动图，上面的理论也比较难懂，建议直接在网上找个视频教程看看了解删除的过程。
还有一种B树的变形B+树，它与B树的区别在于非叶节点仅作为索引作用，不保存具体信息，并且所有的叶节点构成一条有序链表。它相比B树的优点在于一个内存块可以存储更多的关键字（因为B+树只存索引，而B树还保存着信息，所有B+树关键字占用内存少），减少了磁盘io，另外由于所有的叶子节点构成有序链表，所有可以方便的进行范围查询。更多详细请参考：https://blog.csdn.net/qq_26222859/article/details/80631121
