零，二叉树
二叉树的概念：
- 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
- 二叉树的子节点分为左节点和右节点。
- 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。
- 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。
首先，我们用三个 基本 的二叉树代码 来回忆一下什么是 二叉树，以便引出其他的树结构
以下代码的精髓就是 递归
public void preOrder(){//前序遍历
System.out.println(this);
if(this.left != null){
this.left.preOrder();
}
if(this.right != null){
this.right.preOrder();
}
}
public void delNode(int no){ //删除
if(this.left != null && this.left.no == no){
this.left=null;
return;
}
if(this.right != null && this.right.no == no){
this.right=null;
return;
}
if(this.left != null){
this.left.delNode(no);
}
if(this.right != null){
this.right.delNode(no);
}
}
public HeroNode preOrderSearch(int no){//前序遍历查找
if(this.no == no){
return this;
}
HeroNode resNode = null;
if(this.left != null){
resNode = this.left.preOrderSearch(no);
}
if(resNode != null){
return resNode;
}
if(this.right != null){
resNode = this.right.preOrderSearch(no);
}
return resNode;
}
一，顺序存储二叉树
1.1 基本概念
从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，看下面的示意图。
- 上图的二叉树的结点，要求以数组的方式来存放
arr : [1, 2, 3, 4, 5, 6, 6] - 要求在遍历数组 arr时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历
1.2 特点
- 顺序二叉树通常只考虑完全二叉树
- 第n个元素的左子节点为 2 * n + 1
- 第n个元素的右子节点为 2 * n + 2
- 第n个元素的父节点为 (n-1) / 2
- n : 表示二叉树中的第几个元素(按0开始编号如上图所示)
1.3 顺序存储二叉树应用实例：堆排序
八大排序算法中的堆排序，就会使用到顺序存储二叉树，
关于堆排序参照：常见的八种排序算法(图解)
1.5 代码实现：
class ArrBinaryTree{ //编写一个ArrayBinaryTree, 实现顺序存储二叉树遍历
private int[] arr;
public ArrBinaryTree(int[] arr){
this.arr = arr;
}
public void preOrder(int index) { //完成顺序存储二叉树的前序遍历
if(arr == null || arr.length == 0) {
System.out.println("数组为空，不能按照二叉树的前序遍历");
}
System.out.println(arr[index]);
if((index * 2 + 1) < arr.length){
preOrder(index * 2 + 1);
}
if((index * 2 + 2) < arr.length){
preOrder(index * 2 + 2);
}
}
}
二，线索化二叉树
2.1 重要概念
-
n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）
-
这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为 前序线索二叉树、中序线索二叉树 和 后序线索二叉树 三种
-
一个结点的前一个结点，称为前驱结点
-
一个结点的后一个结点，称为后继结点
2.2 应用案例
思路分析: 中序遍历的结果：{8, 3, 10, 1, 14, 6}
说明: 当线索化二叉树后，Node节点的 属性 left 和 right ，有如下两种情况：
- left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.
- right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点.
2.3 代码实现：
编写对 二叉树 进行中序线索化的方法
public void threadedNodes(HeroNode node) {
if(node == null) {
return;
}
//(一)先线索化左子树
threadedNodes(node.getLeft());
//(二)线索化当前结点[有难度]
if(node.getLeft() == null) {//处理当前结点的前驱结点
node.setLeft(pre); //让当前结点的左指针指向前驱结点
node.setLeftType(1);//修改当前结点的左指针的类型,指向前驱结点
}
if (pre != null && pre.getRight() == null) {//处理后继结点
pre.setRight(node);//让前驱结点的右指针指向当前结点
pre.setRightType(1);//修改前驱结点的右指针类型
}
pre = node;//每处理一个结点后，让当前结点是下一个结点的前驱结点
//(三)在线索化右子树
threadedNodes(node.getRight());
}
遍历线索化二叉树的方法
public void threadedList() {
HeroNode node = root;//定义一个变量，存储当前遍历的结点，从root开始
while(node != null) {
//循环的找到leftType == 1的结点，第一个找到就是8结点
//后面随着遍历而变化,因为当leftType==1时，说明该结点是按照线索化,处理后的有效结点
while(node.getLeftType() == 0) {
node = node.getLeft();
}
System.out.println(node);
while(node.getRightType() == 1) {//如果当前结点的右指针指向的是后继结点,就一直输出
node = node.getRight();//获取到当前结点的后继结点
System.out.println(node);
}
node = node.getRight();//替换这个遍历的结点
}
}//8,3,10,1,14,6
三，赫夫曼树(最优二叉树)
-
给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree), 还有的书翻译为霍夫曼树。
-
赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
3.1 重要概念
-
路径和路径长度：
在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。
通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1 -
结点的权及带权路径长度：
若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。
结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积 -
树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL(weighted path length) ,权值越大的结点离根结点越近的二叉树才是最优二叉树。
-
WPL最小的就是赫夫曼树(下图中间的那个wpl=59)
3.2 构造步骤
- 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树。
- 取出根节点权值最小的两颗二叉树 。
- 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和。
- 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树。
代码实现
public void HuffmanTree(){
int arr[] = { 13, 7, 8, 3, 29, 6, 1 };
List<HuffNode> nodes = new ArrayList<>();
for (int value : arr) {
nodes.add(new HuffNode(value));
}
while(nodes.size() > 1){
Collections.sort(nodes);//每次都需要排序
HuffNode leftNode = nodes.get(0);//(1)取出根节点权值最小的两颗二叉树
HuffNode rightNode = nodes.get(1);
//(2)构建一颗新的二叉树
HuffNode parent = new HuffNode(leftNode.value + rightNode.value);
parent.left = leftNode;
parent.right = rightNode;
nodes.remove(leftNode);//(3)从ArrayList删除处理过的二叉树
nodes.remove(rightNode);
nodes.add(parent);//(4)将parent加入到nodes
}
nodes.get(0).preOrder();//前序遍历
}
class HuffNode implements Comparable<HuffNode> {
int value;
HuffNode left;
HuffNode right;
public void preOrder() {//前序遍历
System.out.println(this);
if (this.left != null) {
this.left.preOrder();
}
if (this.right != null) {
this.right.preOrder();
}
}
public HuffNode(int value) {
this.value = value;
}
@Override
public String toString() {
return "HuffNode{" +
"value=" + value +
'}';
}
@Override
public int compareTo(HuffNode o) {
return this.value - o.value;// 表示从小到大排序
}
}
3.3 赫夫曼树运用：压缩与解压
四，二叉排序树
二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。
特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点
比如 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为：
4.1 创建
public void add(Node node) {
if(node == null) {
return;
}
//判断传入的结点的值，和当前子树的根结点的值关系
if(node.value < this.value) {
if(this.left == null) {//如果当前结点左子结点为null
this.left = node;
} else {
this.left.add(node);//递归的向左子树添加
}
} else { //添加的结点的值大于 当前结点的值
if(this.right == null) {
this.right = node;
} else {
this.right.add(node);//递归的向右子树添加
}
}
}
4.2 删除
二叉排序树的删除情况比较复杂，有下面三种情况需要考虑
- 删除叶子节点 (比如：2, 5, 9, 12)
- 删除只有一颗子树的节点 (比如：1)
- 删除有两颗子树的节点. (比如：7, 3，10 )
public void delNode(int value) {
if (root == null) {
return;
} else {
AVLNode targetNode = search(value);
if (targetNode == null) return;
if (root.left == null && root.right == null) {
root = null;
return;
}
AVLNode parent = searchParent(value);
if (targetNode.left == null && targetNode.right == null) {// 如果要删除的结点是叶子结点
if (parent.left != null && parent.left.value == value) {
parent.left = null;
} else if (parent.right != null && parent.right.value == value) {
parent.right = null;
}
} else if (targetNode.left != null && targetNode.right != null) {// 删除有两颗子树的节点
AVLNode target = targetNode.right;
while (target.left != null) {
target = target.left;
}
delNode(target.value);
targetNode.value = target.value;
} else {// 删除只有一颗子树的结点
if (targetNode.left != null) {
if (parent != null) {
if (parent.left.value == value) {
parent.left = targetNode.left;
} else {
parent.right = targetNode.left;
}
} else {
root = targetNode.left;
}
} else {
if (parent != null) {
if (parent.left.value == value) {
parent.left = targetNode.right;
} else {
parent.right = targetNode.right;
}
} else {
root = targetNode.right;
}
}
}
}
}
public Node search(int value) {
if(value == this.value) {
return this;
} else if(value < this.value) {//如果查找的值小于当前结点，向左子树递归查找
//如果左子结点为空
if(this.left == null) {
return null;
}
return this.left.search(value);
} else { //如果查找的值不小于当前结点，向右子树递归查找
if(this.right == null) {
return null;
}
return this.right.search(value);
}
}
public Node searchParent(int value) {
//如果当前结点就是要删除的结点的父结点，就返回
if((this.left != null && this.left.value == value) ||
(this.right != null && this.right.value == value)) {
return this;
} else {
//如果查找的值小于当前结点的值, 并且当前结点的左子结点不为空
if(value < this.value && this.left != null) {
return this.left.searchParent(value); //向左子树递归查找
} else if (value >= this.value && this.right != null) {
return this.right.searchParent(value); //向右子树递归查找
} else {
return null; // 没有找到父结点
}
}
}
五，平衡二叉树(AVL树)
- 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效率较高。
- 具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。
5.1 获取高度
public int height() {
return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
}
public int leftHeight() {
if (left == null) {
return 0;
}
return left.height();
}
public int rightHeight() {
if (right == null) {
return 0;
}
return right.height();
}
5.2 定义左右旋转
private void leftRotate() {
AVLNode newNode = new AVLNode(value);//创建新的结点，以当前根结点的值
newNode.left = left;
newNode.right = right.left;
value = right.value;
right = right.right;
left = newNode;
}
private void rightRotate() {
AVLNode newNode = new AVLNode(value);
newNode.right = right;
newNode.left = left.right;
value = left.value;
left = left.left;
right = newNode;
}
5.3 创建
public void add(AVLNode node) {
if (node == null) {
return;
}
if (node.value < this.value) {
if (this.left == null) {
this.left = node;
} else {
this.left.add(node);
}
} else {
if (this.right == null) {
this.right = node;
} else {
this.right.add(node);
}
}
//当添加完一个结点后，如果: (右子树的高度-左子树的高度) > 1 , 左旋转
if (rightHeight() - leftHeight() > 1) {
//如果它的右子树的左子树的高度大于它的右子树的右子树的高度
if (right != null && right.leftHeight() > rightHeight()) {
right.rightHeight();
leftRotate();
} else {
leftRotate();
}
return;//必须要!!!
}
if (leftHeight() - rightHeight() > 1) {
if (left != null && left.rightHeight() > left.leftHeight()) {
left.leftRotate();
rightRotate();
} else {
rightRotate();
}
}
}
六，B树，2-3树，B*树，B+树
6.0. 二叉树的问题分析
二叉树的操作效率较高，但是也存在问题, 请看下面的二叉树
二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)， 就存在如下问题：
- 在构建二叉树时，需要多次进行i/o操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响
- 节点海量，也会造成二叉树的高度很大，会降低操作速度.
6.1 B树的基本介绍
B树通过重新组织节点，降低树的高度，并且减少i/o读写次数来提升效率。
- 如图B树通过重新组织节点， 降低了树的高度.
- 文件系统及数据库系统的设计者利用了磁盘预读原理，将一个节点的大小设为等于一个页(页得大小通常为4k)，这样每个节点只需要一次I/O就可以完全载入
- 将树的度M设置为1024，在600亿个元素中最多只需要4次I/O操作就可以读取到想要的元素, B树(B+)广泛应用于文件存储系统以及数据库系统中
6.2 2-3树（最简单的B树结构）
将数列{16, 24, 12, 32, 14, 26, 34, 10, 8, 28, 38, 20} 构建成2-3树，并保证数据插入的大小顺序。
插入规则:
- 2-3树的所有叶子节点都在同一层.(只要是B树都满足这个条件)
- 有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个子节点.
- 有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个子节点
- 当按照规则插入一个数到某个节点时，不能满足上面三个要求，就需要拆，先向上拆，如果上层满，则拆本层，拆后仍然需要满足上面3个条件。
- 对于三节点的子树的值大小仍然遵守(BST 二叉排序树)的规则
除了23树，还有234树等，概念和23树类似，也是一种B树。 如图:
B-tree树即B树，B即Balanced，平衡的意思。有人把B-tree翻译成B-树，容易让人产生误解。会以为B-树是一种树，而B树又是另一种树。实际上，B-tree就是指的B树。
6.3 B树
前面已经介绍了2-3树和2-3-4树，他们就是B树(英语：B-tree 也写成B-树)，这里我们再做一个说明，我们在学习Mysql时，经常听到说某种类型的索引是基于B树或者B+树的，如图:
B树的说明:
- B树的阶：节点的最多子节点个数。比如2-3树的阶是3，2-3-4树的阶是4
- B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点
- 关键字集合分布在整颗树中, 即叶子节点和非叶子节点都存放数据.
- 搜索有可能在非叶子结点结束
- 其搜索性能等价于在关键字全集内做一次二分查找
6.4 B+树
B+树是B树的变体，也是一种多路搜索树。
B+树的说明:
- B+树的搜索与B树也基本相同，区别是B+树只有达到叶子结点才命中（B树可以在非叶子结点命中），其性能也等价于在关键字全集做一次二分查找
- 所有关键字都出现在叶子结点的链表中（即数据只能在叶子节点【也叫稠密索引】），且链表中的关键字(数据)恰好是有序的。
- 不可能在非叶子结点命中
- 非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层
- 更适合文件索引系统
- B树和B+树各有自己的应用场景，不能说B+树完全比B树好，反之亦然.
6.5 B*树
B*树是B+树的变体，在B+树的非根和非叶子结点再增加指向兄弟的指针。
B*树的说明:
- B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为2/3，而B+树的块的最低使用率为B+树的1/2。
- 从第1个特点我们可以看出，B* 树分配新结点的概率比B+树要低，空间使用率更高
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
