零,二叉树
二叉树的概念:
- 树有很多种,每个节点最多只能有两个子节点的一种形式称为二叉树。
- 二叉树的子节点分为左节点和右节点。
- 如果该二叉树的所有叶子节点都在最后一层,并且结点总数= 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+树要低,空间使用率更高