数据结构与算法（java）：树-二叉树（二叉查找树（BST）、线索化二叉树、哈夫曼树、平衡二叉树【AVL】、二叉树的前中后序遍历）
二叉树
1、定义
二叉树
就是度不超过2的树（每个结点最多只有两个子结点）。如图
2、特殊二叉树
满二叉树
当二叉树的每一个层的结点树都达到最大值，则这个二叉树就是满二叉树。
完全二叉树
叶结点只能出现在最下层和次下层，且最下面一层的结点都集中在该层最左边的若干位置的二叉树。就是说你结点尽量往左边靠，先把左边位置填满。
斜二叉树
分为左斜树（所有的结点都只有左子树的二叉树）和右斜树（所有的结点都只有右子树的二叉树）。
3、二叉树的性质
（1）二叉树的第i层中至多有2^i-1个结点（i>=1）
（2）深度为k的二叉树至多有2^k-1个结点（k>=1）
（3）对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1
（4）具有n个结点的完全二叉树的深度为不大于log2^n的最大整数再加1。
（5）如果对一棵有n个结点的完全二叉树（其深度为不大于log2^n的最大整数再加1）的结点按层序编号，对任意结点i（1<=i<=n）有：
- 如果i=1，那么结点i是二叉树的根，无双亲；如果i>1,那么其双亲是结点不大于i/2的最大整数
- 如果2i>n,那么结点i无左孩子（结点i为叶结点）；否则其左孩子是结点2i
- 如果2i+1>n，则结点i无右孩子，否则其右孩子是结点2i+1
4、 二叉树的存储结构
4.1 顺序存储结构
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系，如双亲与孩子的关系，兄弟关系等。从数据存储来看，数组存储方式和树的存储方式间课相互转换
下面是完全二叉树的顺序存储，转换为数组（右图）
对于一般的二叉树尽管层序编号不能反映逻辑关系但是可以将其按完全二叉树编号，不过，将不存在的结点设置为“^”。如下
但当k深度的右斜树出现时，顺序存储会对存储空间造成很大浪费，所以一般这种顺序存储结构只用于完全二叉树
观察数组中的存储规律可以知道顺序存储胡二叉树的特点，如下：
（1）顺序二叉树通常只考虑完全二叉树
（2）第n个元素的左子结点为2n+1
（3）第n个元素的右子结点为2n+2
（4）第n个元素的父结点为（n-1）/2
（5）n表示的是二叉树中的第n个元素（从0开始编号）
因为通常只考虑完全二叉树，所以可以使用一个有值的数组来模拟已经实现好的完全二叉树，具体实现可以看遍历那节。
4.2 链式存储结构
二叉树的每个结点最多有两个孩子，所以为它设计一个数据域和两个指针域（lchild左指针指向左子树，rchild有有指针指向右子数），这样的链表叫做二叉链表。如图
5、二叉查找树（BST）
简介
二叉查找树，也叫二叉排序树，BST（Binary Sort 【Search】 Tree），对于二叉排序树的任何一个非叶子结点，要求左子结点的值要比当前结点的值小，右子结点的值要比当前结点的值大，如果有相同大小的值，可以将该结点放在左子结点或者右子结点。
二叉查找树原理就是利用键值对中的键的大小来排好结点的顺序，方便查找树中的某个结点，
方法原理分析
（一）insertNode()方法：创建树或添加新结点的实现
1、如果当前树中没有任何一个结点，则直接把新结点当做根结点使用
2、如果当前树不为空，则从根结点开始：
（1）如果新结点的key小于当前结点的key，则继续找当前结点的左子结点
（2）如果新结点的key大于当前结点的key，则继续找当前结点的右子结点
（3）如果新结点的key等于当前结点的key，则树中返回当前结点的value
（二）getValue()方法：获取对应的结点的key或者value
从根结点开始，
1、如果要查找的结点的key小于当前结点的key，则继续找当前结点的左子结点
2、如果要查询的结点的key大于当前结点的key，则继续找当前结点的右子结点
3、如果要查询的结点的key等于当前结点的key，则树中返回当前结点的value
（三）deleteNode()方法：删除指定结点
1、找到要删除的结点
2、找到被删除结点右子树中的最小结点minNode
3、被删除结点的父结点指向被删除结点右子树中的最小结点
代码实现
/**** @param <Key> 泛型类，用来表示树中结点的键，并且继承了Comparable接口* @param <Value> 泛型类，用来表示树中结点对应的值*/
public class Tree <Key extends Comparable<Key>,Value>{//结点类private class Node{/*** key和value都是泛型类的，可以接收任何类型的值* left 左子结点* right 右子结点*/private Key key;private Value value;private Node left;private Node right;public Node(Key key, Value value, Node left, Node right) {this.key = key;this.value = value;this.left = left;this.right = right;}}private Node root; //根结点private int numOfNode; //结点数目//获取树中结点的数目public int getNumOfNode(){return numOfNode;}//---------------------------------------------------------------------------------//插入（添加）结点（键值对key-value）,并返回插入结点后的树public void insertNode(Key key, Value value){//调用重载的insertNode()方法，传入的结点是根结点,并且根结点默认取值key=null，value=null;root = insertNode(root, key, value);}//向node子树插入（添加）结点（键值对）private Node insertNode(Node node, Key key, Value value){//当node子树为空树时，创建结点if(node == null){//每次创建一个结点时，结点个数加1numOfNode++;//创建好一个结点并返回，并且这个结点的左右子结点均为空return new Node(key, value, null, null);}//当子树不为空树时，找到树中合适的位置插入结点/*调用Comparable接口中compareTo方法比较插入结点的key和子树结点的key的大小以此来决定插入结点的插入位置*/int cmp = key.compareTo(node.key);//递归if(cmp < 0){//插入结点的key小于子树结点的key时，继续找子树的左子树node.left = insertNode(node.left, key, value);}else if(cmp > 0){//插入结点的key大于子树结点的key时，继续找子树的右子树node.right = insertNode(node.right, key, value);}else{//插入结点的key等于子树结点的key时，替换node结点中value的值node.value = value;}//返回nodereturn node;}//---------------------------------------------------------------------------------//查询树中指定key对应的value值public Value getValue(Key key){//调用重载方法getValue(),返回找到的value值return getValue(root, key);}//查询子树中指定key对应的value值private Value getValue(Node node, Key key){if(node == null){return null;}int cmp = key.compareTo(node.key);if(cmp<0){return getValue(node.left, key);}else if(cmp > 0){return getValue(node.right, key);}else{return node.value;}}//---------------------------------------------------------------------------------//根据键值key删除树中指定结点public void deleteNode(Key key){//调用重载的方法deleteNode();deleteNode(root, key);}//删除某个子树中指定了key值的结点private Node deleteNode(Node node, Key key){//先判断子树是否为空，为空则返回null或者抛出异常都可以if(node == null){return null;}//如果树非空，接下来就是从根结点开始找到要删除的结点int cmp = key.compareTo(node.key);if(cmp<0){//当要插入的结点的key小于node树的左子结点时，继续递归找子树的左子结点node.left = deleteNode(node.left, key);}else if(cmp>0){//当要插入的结点的key大于node树的左子结点时，继续递归找子树的右子结点node.right = deleteNode(node.right,key);}else{//结点数量减1numOfNode--;/* 当找到要删除的结果时，完成删除操作,删除后将子树的父结点指向子树的右子树中中最小的左子结点 *///判断某树的右子结点是否为空，为空则去找某树的左子结点if(node.right == null){return node.left;}//判断某树的左子结点是否为空，为空则去找某树的右子结点if (node.left == null) {return node.right;}//找右子树中的最小值用minNode接收。Node minNode = node.right;while(minNode.left != null){minNode = minNode.left;}/* 有这么几种情况：* (1) 当node是叶结点时，左右子结点都为null* (2) node右子结点为空，但左子结点非空时，则会去找node左子树中的右子树的最小值* (3) node左子结点为空，但右子结点非空时，则直接去找node右子树中的最小值（就是上面两个if语句中第一个语句不成立，第二个语句成立的情况）* (4) node左右子结点都非空时，则直接找node右子树中的最小值（就是上面两个if语句都不成立的情况)*/Node n = node.right; //node的右子树//判断待删除结点的右子树的左子树是否为空，为空则直接让待删除结点的右子树成为minNode的左子树，并且让minNode代替被删除的结点的位置if(n.left == null){minNode.left = node.left;node = minNode;}else {//当待删除结点的右子树的左子树不为空，则循环找到其右子树的左子树下的最小值while (n.left != null) {//如果node的右子树的左子树没有左子结点了，则使这个左子树独立出来if (n.left.left == null) {n.left = null;} else {//如果node的右子树的左子树还有左子结点，则继续找最小结点n = n.left;}}//删除操作完成后将子树的父结点指向子树的右子树中中最小的左子结点，并返回新组成的树//让node结点的左子树成为minNode的左子树minNode.left = node.left;//当待删结点的右子结点不是minNode时，让待删结点的右子树成为minNode的右子树if(minNode != node.right){minNode.right = node.right;}}//如果删除的结点是根结点，那么让找到的minNode成为根结点if(node == root){root = minNode;}else {node = minNode;}}return node;}//---------------------------------------------------------------------------------//查找整个树中的最小结点public Key getMinNode(){return getMinNode(root).key;}private Node getMinNode(Node node){while(node.left != null){node = node.left;}return node;}//---------------------------------------------------------------------------------//查找整个树中的最大结点public Key getMaxNode(){return getMaxNode(root).key;}private Node getMaxNode(Node node){while(node.right != null){node = node.right;}return node;}
}
5、线索化二叉树
6、哈夫曼树
7、平衡二叉树（AVL树）
待补充2022/3/6
8、二叉树的遍历
概述
问题描述：
树的遍历不像数组，集合的遍历一样，树状结构和线性结构是不同的，没有办法从头开始一次向后遍历，所以需要一些特殊的搜索路径来进行遍历，常用的基础遍历方式（深度优先思想）有前序遍历，中序遍历，后序遍历。。。(这里的前中后可以理解成根结点访问的位置和顺序，例如先访问根结点叫前序，中间访问根结点叫中序，最后访问根结点叫做后序），高级遍历方式（广度优先思想）有层序遍历。
如图：
前序遍历：EBADCGFH
中序遍历：ABCDEFGH
后序遍历：ACDBFHGE
层序遍历：EBGADFHC
链式存储的遍历
前序遍历
特点
先访问根节点，再访问左子树，最后访问右子树
实现步骤
（1）把当前结点的key放入到队列中
（2）找到当前结点的左子树，如果不为空，递归遍历左子树
（3）找到当前结点的右子树，如果不为空，递归遍历右子树
我这里的LinkedQueue是已经实现了了链式队列，里面有入队方法，专门用来存储树前中序遍历后的结点
代码如下
//前序遍历//获取整个树中所有的键public LinkedQueue<Key> preErgodic(){LinkedQueue<Key> keys = new LinkedQueue<Key>();preErgodic(root,keys);return keys;}//获取指定树x中的所有键，并放到keys队列中private void preErgodic(Node x, LinkedQueue<Key> keys ){if(x==null){return ;}//将x结点的key放入到keys中keys.Enqueue(x.key);//递归遍历x结点的左子树if(x.left != null){preErgodic(x.left,keys);}//递归遍历x结点的右子树if(x.right != null){preErgodic(x.right,keys);}}
中序遍历
特点
先访问左子树，再访问根节点，最后访问右子树
实现步骤
（1）找到当前结点的左子树，如果不为空，递归遍历左子树
（2）把当前结点的key放入到队列中
（3）找到当前结点的右子树，如果不为空，递归遍历右子树
代码如下
//中序遍历//获取整个树中所有的键public LinkedQueue<Key> midErgodic(){LinkedQueue<Key> keys = new LinkedQueue<>();midErgodic(root,keys);return keys;}//把指定树x中的所有键放入到队列keys中public void midErgodic(Node x, LinkedQueue<Key> keys){if(x == null){return ;}//先递归将左子树中的键放入到队列keys中if(x.left != null){midErgodic(x.left, keys);}//再递归将x结点的key放入到keys中keys.Enqueue(x.key);//递归将右子树中的键放入到队列keys中if(x.right != null){midErgodic(x.right, keys);}}
后序遍历
特点
先访问左子树，再访问右子树，最后访问根节点
实现步骤
（1）找到当前结点的左子树，如果不为空，递归遍历左子树
（2）找到当前结点的右子树，如果不为空，递归遍历右子树
（3）把当前结点的key放入到队列中
代码如下
//后序遍历//获取整个树中的所有键public LinkedQueue<Key> afterErgodic(){LinkedQueue<Key> keys = new LinkedQueue<>();afterErgodic(root,keys);return keys;}//获取树x中的所有键并将它们放入到keys队列中public void afterErgodic(Node x, LinkedQueue<Key> keys){if(x == null){return ;}//先递归将左子树中的key放入到队列keys中if(x.left != null){afterErgodic(x.left, keys);}//再递归将右子树中的key放入到keys中if(x.right != null){afterErgodic(x.right, keys);}//递归将x结点的key放入到队列keys中keys.Enqueue(x.key);}
层序遍历
特点
按照树的从上到下，从左到右的顺序遍历,用到的是广度优先思想
步骤
1、创建队列存储每一层的结点
2、使用循环从队列中弹出一个结点
（1）获取当前结点的key
（2）如果当前结点的左结点不为空，则把左结点放入到队列中
（3）如果当前结点的右结点不为空，则把右结点放入到队列中
代码如下
//层序遍历public LinkedQueue<Key> layerErgodic(){//定义两个队列，分别用来存储树中的键和结点LinkedQueue<Key> keys = new LinkedQueue<>();LinkedQueue<Node> nodes = new LinkedQueue<>();//默认：往队列中放入根结点nodes.Enqueue(root);while(!nodes.isEmpty()){//从队列中弹出一个结点，将key放入到keys中Node n = nodes.Dequeue();keys.Enqueue(n.key);//判断当前结点还有没有左结点，有则放入nodes中if(n.left != null){nodes.Enqueue(n.left);}//判断当前结点还有没有右结点，有则放入nodes中if(n.right != null){nodes.Enqueue(n.right);}}return keys;}
这四种遍历的测试代码及结果如下（这里借用了上面二叉排序树的代码BinaryTree类创建了二叉树）
public static void main(String[] args) {BinaryTree<String, String> sbt = new BinaryTree<>();sbt.put("E","5");sbt.put("B","2");sbt.put("G","7");sbt.put("A","1");sbt.put("D","4");sbt.put("F","6");sbt.put("H","8");sbt.put("C","3");LinkedQueue<String> keys1 = sbt.preErgodic();//前序遍历System.out.println("前序遍历---------");for(String key : keys1){String value = sbt.get(key);System.out.println(key + "----" + value);}//中序遍历System.out.println("中序遍历---------");LinkedQueue<String> keys2 = sbt.midErgodic();for(String key : keys2){String value = sbt.get(key);System.out.println(key + "----" + value);}//后序遍历System.out.println("后序遍历--------");LinkedQueue<String> keys3 = sbt.afterErgodic();for(String key : keys3){String value = sbt.get(key);System.out.println(key + "----" + value);}//层序遍历System.out.println("层序遍历-------");LinkedQueue<String> keys4 = sbt.layerErgodic();for(String key : keys4){String value = sbt.get(key);System.out.println(key + "----" + value);}}前序遍历---------
E----5
B----2
A----1
D----4
C----3
G----7
F----6
H----8
中序遍历---------
A----1
B----2
C----3
D----4
E----5
F----6
G----7
H----8
后序遍历--------
A----1
C----3
D----4
B----2
F----6
H----8
G----7
E----5
层序遍历-------
E----5
B----2
G----7
A----1
D----4
F----6
H----8
C----3
顺序存储的遍历
主要原理如下：
（1）第n个元素的左子结点为2n+1
（2）第n个元素的右子结点为2n+2
（3）第n个元素的父结点为（n-1）/2
（4）n表示的是二叉树中的第n个元素（从0开始编号）
具体实现
public class ArrBinaryTree {private int[] arr; //存储数据的数组public ArrBinaryTree(int[] arr) {this.arr = arr;}//前序遍历public void preOrder(){this.preOrder(0); //默认是从数组索引0处开始遍历}//重载public void preOrder(int index){if(arr == null || arr.length == 0){System.out.println("数组为空！！！");return ;}//输出当前结点System.out.print(arr[index] + " ");//向左递归遍历if((index*2 + 1) < arr.length){preOrder(2*index + 1);}//向右递归遍历if((index*2 + 2) < arr.length){preOrder(2*index + 2);}}//中序遍历public void midOrder(){midOrder(0);}public void midOrder(int index){if(arr == null || arr.length == 0){System.out.println("数组为空");return;}//先递归遍历左子结点if((index*2+1) < arr.length){midOrder(2*index+1);}//输出当前结点System.out.print(arr[index] + " ");//向右递归遍历if((index*2 + 2) < arr.length){midOrder(2*index+2);}}//后序遍历public void lastOrder(){lastOrder(0);}public void lastOrder(int index){if(arr == null || arr.length == 0){System.out.println("数组为空！！！");return;}//向左递归遍历if((2*index + 1) < arr.length){lastOrder(2*index + 1);}//向右递归遍历if((2*index + 2) < arr.length){lastOrder(2*index + 2);}//输出当前结点System.out.print(arr[index] + " ");}
}测试代码：
public class Test {public static void main(String[] args) {int[] arr = {1,2,3,4,5,6,7};ArrBinaryTree tree = new ArrBinaryTree(arr); //传入一个数组(模拟二叉树)System.out.println("前序遍历");tree.preOrder();System.out.println("\n" + "中序遍历");tree.midOrder();System.out.println("\n" + "后序遍历");tree.lastOrder();}
}结果如下：
前序遍历
1 2 4 5 3 6 7
中序遍历
4 2 5 1 6 3 7
后序遍历
4 5 2 6 7 3 1
9、二叉树的前序、中序、后序查找
前中后序查找的思路和遍历的思路很相似，这里只简述下思路，实现方式和遍历差不多
思路如下：
（1）前序查找思路：
1、先判断当前结点的node是否等于要找的结点，
2、相等，则返回当前结点，不相等，则判断当前结点的左子结点是否为空，如果不为空，则递归前序查找
3、如果左递归前序查找找到结点，则返回，否则继续判断
4、左递归查找完还没找到要找的结点，则进行右递归前序查找，找到则返回结点，否则继续判断
（2）中序和后序的思路都是换汤不换药。。。就不写了
10、相关问题
最大深度问题
问题描述
给定一棵树，计算树的最大深度（树的根结点到最远叶结点的最长路径上的结点数）
实现步骤
1、如果根结点为空，则最大深度为0
2、计算左子树的最大深度
3、计算右子树的最大深度
4、当前树的最大深度=左子树的最大深度和右子树的最大深度中的最大者加1
代码如下
//计算整个树的最大深度public int maxDepth(){return maxDepth(root);}//计算指定树x的最大深度public int maxDepth(Node x){if(x == null){return 0;}int max = 0;int maxL = 0;int maxR = 0;//计算x结点左子树的最大深度if(x.left != null){maxL = maxDepth(x.left);}//计算x结点右子树的最大深度if(x.right != null){maxR = maxDepth(x.right);}//比较左右子树，取其中的最大者再加1max = maxL>maxR?maxL+1:maxR+1;return max;}
数据结构与算法（java）：树-二叉树（二叉查找树（BST）、线索化二叉树、哈夫曼树、平衡二叉树【AVL】、二叉树的前中后序遍历）相关推荐
- 二叉树的前,中,后序遍历(思路分析) [Java][数据结构]
二叉树的前,中,后序遍历(思路分析) 前序遍历: 先输出父节点, 再遍历左子树和右子树 中序遍历: 先遍历左子树, 再输出父节点,再遍历右子树 后序遍历: 先遍历左子树,再遍历右子树,最后输出父节点 ...
- 二叉树前中后序遍历+刷题【中】【数据结构/初阶/C语言实现】
文章目录 1. 二叉树基础操作 1.1 二叉树遍历 1.1.1 前序遍历 前序遍历(Pre-Order Traversal) 1.1.2 中序遍历 中序遍历(In-Order Traversal) 1 ...
- 数据结构-二叉树（包含二叉树的层次建树、前中后序遍历、层次遍历解析及代码）
目录 一.树与二叉树的原理解析 1.树的定义 2.树的结构和特点 3.二叉树的定义 4.树结点的数据结构 二.二叉树的层次建树 1.二叉树层次建树的原理及分析 2.完整代码 三.二叉树的前中后序遍历 ...
- [Leedcode][JAVA][第94/144/145题][前中后序遍历][递归][迭代][二叉树]
[问题描述][] 前序遍历 先输出当前结点的数据,再依次遍历输出左结点和右结点 中序遍历 先遍历输出左结点,再输出当前结点的数据,再遍历输出右结点 后续遍历 先遍历输出左结点,再遍历输出右结点,最后输 ...
- Java二叉树的前中后序遍历
Java二叉树的前中后序遍历 1.前序遍历 1.1前序遍历概念 1.2前序遍历习题 2.中序遍历 2.1中序遍历概念 2.2中序遍历习题 3.后续遍历 3.1后序遍历概念 3.2后序遍历习题 大家好, ...
- LeetCode——树：层次遍历、前中后序遍历
LeetCode--树:层次遍历.前中后序遍历 目录 层次遍历 二叉树的层平均值 找树左下角的值 前中后序遍历 概述 非递归实现二叉树的前序遍历 非递归实现二叉树的中序遍历 非递归实现二叉树的后序遍历 ...
- 二叉树前中后序遍历以及节点计算
二叉树前中后序遍历以及节点计算 二叉树 分类 二叉链的数据结构 三叉链的数据结构 四种遍历方法 深度优先遍历:前中后序 广度优先遍历:层序遍历 计算 节点个数 叶子节点个数 树的高度 第k层的节点个数 ...
- 二叉树前中后序遍历的非递归实现以及层次遍历、zig-zag型遍历详解
前言 二叉树的遍历是一个比较常见的问题,递归实现二叉树的前中后序遍历比较简单,但非递归实现二叉树的前中后序遍历相对有难度.这篇博客将详述如何使用非递归的方式实现二叉树的前中后序遍历,在进行理论描述的同 ...
- python实现二叉树非递归前中后序遍历
python实现二叉树非递归前中后层序遍历 二叉树是数据结构中重要的一部分,本文简单介绍用python实现二叉树的前中后序遍历,包括递归和非递归思路算法. # -*- 二叉树 begin -*- # ...
- 代码随想录——二叉树（一）：前中后序遍历，层序遍历，翻转
题目来自:https://www.programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80. ...
最新文章
- XCMS | LC/MS and GC/MS Data Analysis
- PL/SQL Developer 导出表结构和表数据
- c语言 文件截断,c – 是否有一种正统的方法来避免编译器警告C4309 – “二进制文件输出的”常数值的截断“？...
- 基于深度学习的多目标跟踪算法（上）：端到端的数据关联
- 委派用户管理Hyper-v
- 数据库更改到Java环境中实现可持续和平
- 程序员面试金典 - 面试题 17.05. 字母与数字（哈希map+思维转换）
- OC学习篇之---类的初始化方法和点语法的使用
- android 编译 sdl,SDL编译 - Android本地视频播放器开发_Linux编程_Linux公社-Linux系统门户网站...
- kubernetes视频教程笔记 （20）-ingress
- 软考高级 真题 2017年上半年 信息系统项目管理师 综合知识
- 生猪价格matlab,2447教务处.doc
- 嵌入式软件开发到底是干什么的？
- 【沧小海笔记】之基于FPGA的以太网设计相关知识——第一章 互联网概述
- Classloader整理
- 【毕业设计_课程设计】基于python的微信公众平台机器人的设计与实现
- Ubuntu的共享文件夹
- 春风十里，不如见到你
- [益智]：找规律习题
- java实现FTP协议:wireshark抓包解析