二叉树
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){
//每次创建一个结点时，结点个数加1
numOfNode++;
//创建好一个结点并返回，并且这个结点的左右子结点均为空
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;
}
//返回node
return 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{
//结点数量减1
numOfNode--;
/* 当找到要删除的结果时，完成删除操作,删除后将子树的父结点指向子树的右子树中中最小的左子结点 */
//判断某树的右子结点是否为空，为空则去找某树的左子结点
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);
}
//比较左右子树，取其中的最大者再加1
max = maxL>maxR?maxL+1:maxR+1;
return max;
}
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
