树是我们计算机中非常重要的一种数据结构,同时使用树这种数据结构,可以描述现实生活中的很多事物,例如家谱、单位的组织架构等等
树是由n(n>=1)个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。
树具有以下特点:
-
每个结点有 零个或多个 子结点
-
没有父结点的结点为 根结点
-
每一个非根结点 只有一个 父结点
-
每个结点及其后代结点整体上可以看做是一棵树,称为当前结点的父结点的一个 子树
7.1、树的相关术语
-
结点的度
一个结点含有的子树的个数称为该结点的度
-
叶结点
度为0的结点称为叶结点,也可以叫做终端结点
-
分支结点
度不为0的结点称为分支结点,也可以叫做非终端结点
-
结点的层次
从根结点开始,根结点的层次为1,根的直接后继层次为2,以此类推
-
结点的层序编号
将树中的结点,按照从上层到下层,同层从左到右的次序排成一个线性序列,把他们编成连续的自然数
-
树的度
树中所有结点的度的最大值
-
树的高度(深度)
树中结点的最大层次
-
森林
m(m>=0)个互不相交的树的集合,将一颗非空树的根结点删去,树就变成一个森林;给森林增加一个统一的根结点,森林就变成一棵树
-
孩子结点
一个结点的直接后继结点称为该结点的孩子结点
-
双亲结点(父结点)
一个结点的直接前驱称为该结点的双亲结点
-
兄弟结点
同一双亲结点的孩子结点间互称兄弟结点
7.2、二叉树的基本定义
-
二叉树
就是度不超过2的树(每个结点最多有两个子结点)
-
满二叉树
一个二叉树,如果每一个层的结点树都达到最大值,则这个二叉树就是满二叉树
-
完全二叉树
叶节点只能出现在 最下层和次下层,并且最下面一层的结点都集中在该层 最左边 的若干位置的二叉树
除最下层外,其余层都是满的
7.3、二叉查找树的创建
1)二叉树的结点类
- 根据对图的观察,我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的,按照面向对象的思想,我们设计一个结点类来描述结点这个事物
- 结点API
public class Node<K,V> {
/**
* 键 key
*/
private K key;
/**
* 值 value
*/
private V value;
/**
* 左子结点
*/
private Node left;
/**
* 右子结点
*/
private Node right;
/**
* 构造器
* @param key
* @param value
* @param left
* @param right
*/
public Node(K key, V value, Node left, Node right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
}
2)二叉查找树API设计
3)二叉查找树实现
-
插入方法put实现思路
-
如果当前树中没有任何一个结点,则直接把新结点当做根结点使用
-
如果当前树不为空,则从根结点开始:
1) 如果新结点的key 小于 当前结点的key,则继续找当前结点的 左子结点
2) 如果新结点的key 大于 当前结点的key,则继续找当前结点的 右子结点
3)如果新结点的key 等于 当前结点的key,则树中已经存在这样的结点,替换 该结点的value值即可
-
-
查询方法get实现思路
从根节点开始:
-
如果要查询的key 小于 当前结点的key,则继续找当前结点的 左子结点
-
如果要查询的key 大于 当前结点的key,则继续找当前结点的 右子结点
-
如果要查询的key 等于 当前结点的key,则树中 返回 当前结点的value
-
-
删除方法delete实现思路
过河拆桥,再建新桥
-
找到被删除结点
-
找到被删除结点 右子树中的最小结点 minNode
-
删除右子树中的最小结点
-
让被删除结点的左子树成为最小结点minNode的左子树,让被删除结点的右子树称为最小结点minNode的右子树
-
让被删除结点的父节点指向最小结点minNode
-
- 代码实现
package chapter05;
/**
* @author 土味儿
* Date 2021/9/7
* @version 1.0
* 二叉树
*/
public class BinaryTree<K extends Comparable<K>, V> {
/**
* 根结点
*/
private Node root;
/**
* 树中元素个数
*/
private int n;
/**
* 构造器
*/
public BinaryTree() {
}
/**
* 向树中插入一个新结点(键值对)
*
* @param key
* @param value
*/
public void put(K key, V value) {
root = put(root, key, value);
}
/**
* 向树x中插入新结点,并返回新树
*
* @param x
* @param key
* @param value
* @return
*/
private Node put(Node x, K key, V value) {
// 如果树x为空,创建新结点,让新结点成为x,元素数量加1,并返回x
if (x == null) {
n++;
return new Node(key, value, null, null);
}
// 如果树x不为空,比较key与x键的大小
int cpt = x.key.compareTo(key);
if (cpt < 0) {
// 如果key 大于 x的键,比较右子树 (递归)
x.right = put(x.right, key, value);
} else if (cpt > 0) {
// 如果key 小于 x的键,比较左子树 (递归)
x.left = put(x.left, key, value);
} else {
// 如果相等,value 替换 x的值
x.value = value;
}
return x;
}
/**
* 找出结点key的值
*
* @param key
* @return
*/
public V get(K key) {
return get(root, key);
}
/**
* 找出树x中结点key的值
*
* @param x
* @param key
* @return
*/
private V get(Node x, K key) {
// 树x为空
if (x == null) {
return null;
}
// 树x不为空,比较key与x键的大小
int cpt = x.key.compareTo(key);
if (cpt < 0) {
// 如果key 大于 x的键,比较右子树 (递归)
return get(x.right, key);
} else if (cpt > 0) {
// 如果key 小于 x的键,比较左子树 (递归)
return get(x.left, key);
} else {
// 如果相等,就找到了,返回x的value
return x.value;
}
}
/**
* 删除结点key
*
* @param key
*/
public void delete(K key) {
delete(root, key);
}
/**
* 删除树x中的结点key,并返回新树
*
* @param x
* @param key
* @return
*/
private Node delete(Node x, K key) {
// 树x为空
if (x == null) {
return null;
}
// 树x不为空,比较key与x键的大小
int cpt = x.key.compareTo(key);
if (cpt < 0) {
// 如果key 大于 x的键,比较右子树 (递归)
x.right = delete(x.right, key);
} else if (cpt > 0) {
// 如果key 小于 x的键,比较左子树 (递归)
x.left = delete(x.left, key);
} else {
// 如果相等,就找到了
// 元素数量减1
n--;
// 特殊情况:当前树x只有一个分叉,左或右
if (x.left == null) {
// 没有左子树,直接返回右子树即可
return x.right;
}
if (x.right == null) {
// 没有右子树,直接返回左子树即可
return x.left;
}
// 左右子树都存在
// 找出右子树中的最小结点minNode,并在右子树中删除minNode
Node minNode;
Node node = x.right;
while (node.left != null) {
// 移动minNode指针
minNode = node.left;
if (node.left.left == null) {
// 如果node.left没有下级结点,即为最小结点,设为null值,即为删除
node.left = null;
} else {
// 如果node.left有下级结点,移动node指针
node = node.left;
}
}
// 让被删除结点x的左子树成为minNode的左子树
minNode.left = x.left;
// 让被删除结点x的右子树(已删除minNode)成为minNode的右子树
minNode.right = x.right;
// 用minNode替换被删除结点x(被删除结点的父节点指向最小结点minNode)
x = minNode;
}
return x;
}
/**
* 获取树中元素个数
*
* @return
*/
public int size() {
return n;
}
/**
* 内部结点类
*/
private class Node {
/**
* 键 key
*/
private K key;
/**
* 值 value
*/
private V value;
/**
* 左子结点
*/
private Node left;
/**
* 右子结点
*/
private Node right;
/**
* 构造器
*
* @param key
* @param value
* @param left
* @param right
*/
public Node(K key, V value, Node left, Node right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
}
}
package chapter05;
import org.junit.Test;
/**
* @author 土味儿
* Date 2021/9/7
* @version 1.0
* 测试二叉树
*/
public class BinaryTreeTest {
@Test
public void test(){
BinaryTree<Integer, String> bt = new BinaryTree<>();
bt.put(5,"张三");
bt.put(2,"李四");
bt.put(8,"王五");
bt.put(6,"赵六");
bt.put(3,"四七");
System.out.println("元素个数:"+bt.size());
bt.put(6,"秦八");
System.out.println("元素个数:"+bt.size());
bt.delete(8);
System.out.println("删除后元素个数:"+bt.size());
System.out.println(bt.get(8));
}
}
元素个数:5
元素个数:5
删除后元素个数:4
null
4)二叉查找树其他便捷方法
1、查找二叉树中最小的键
-
API设计
-
递归方式
-
while循环方式
-
-
代码实现
/**
* 方法一:找出树中最小的键
* while循环方式
*
* @return
*/
public K min1() {
Node x = root;
if (x == null) {
return null;
}
while (x.left != null) {
x = x.left;
}
return x.key;
}
/**
* 方法二:找出树中最小的键
* 递归方式
*
* @return
*/
public K min2() {
Node min = min(root);
if (min != null) {
return min.key;
}
return null;
//return min(root).key;
}
/**
* 找出树x中的最小键的结点
*
* @param x
* @return
*/
private Node min(Node x) {
if (x != null && x.left != null) {
//if (x.left != null) {
return min(x.left);
}
return x;
}
public class BinaryTreeTest {
@Test
public void test(){
BinaryTree<Integer, String> bt = new BinaryTree<>();
bt.put(5,"张三");
bt.put(2,"李四");
bt.put(8,"王五");
bt.put(6,"赵六");
bt.put(3,"四七");
System.out.println("方法1最小键:"+bt.min1());
System.out.println("方法2最小键:"+bt.min2());
}
}
方法1最小键:2
方法2最小键:2
2、查找二叉树中最大的键
-
API设计
- 递归方式
-
while循环方式
-
代码实现
/**
* 方法一:找出树中最大的键
* while循环方式
*
* @return
*/
public K max1(){
Node x = root;
if (x == null) {
return null;
}
while (x.right != null) {
x = x.right;
}
return x.key;
}
/**
* 方法二:找出树中最大的键
* 递归方式
*
* @return
*/
public K max2(){
Node max = max(root);
if (max != null) {
return max.key;
}
return null;
}
/**
* 找出树x中的最大键的结点
*
* @param x
* @return
*/
private Node max(Node x) {
if (x != null && x.right != null) {
return max(x.right);
}
return x;
}
@Test
public void test(){
BinaryTree<Integer, String> bt = new BinaryTree<>();
bt.put(5,"张三");
bt.put(2,"李四");
bt.put(8,"王五");
bt.put(6,"赵六");
bt.put(3,"四七");
System.out.println("方法1最大键:"+bt.max1());
System.out.println("方法2最大键:"+bt.max2());
}
方法1最大键:8
方法2最大键:8
7.4、二叉树的基础遍历
深度优先
很多情况下,可能需要像遍历数组一样遍历树, 从而拿出树中存储的每一个元素,由于树状结构和线性结构不一样,没有办法从头依次向后遍历,所以存在如何遍历,也就是按照什么样的搜索路径进行遍历的问题
把树简单的画作上图中的样子,由一个根节点、一个左子树、一个右子树组成,那么按照 根节点 什么时候被访问,可以把二叉树的遍历分为以下三种方式:
-
前序遍历:根左右
先访问根结点,然后再访问左子树,最后访问右子树
-
中序遍历:左根右
先访问左子树,中间访问根节点,最后访问右子树
-
后序遍历:左右根
先访问左子树,再访问右子树,最后访问根节点
如果分别对下面的树使用三种遍历方式进行遍历,得到的结果如下:
1)前序遍历
-
在上图树上,添加前序遍历的API:
public Queue<Key> preErgodic() // 使用前序遍历,获取整个树中的所有键 private void preErgodic(Node x,Queue<Key> keys) //使用前序遍历,把指定树x中的所有键放入到keys队列中;实现过程中,通过前序遍历,把每个结点的键取出,放入到队列中返回即可
-
实现步骤
-
把当前结点的key放入到队列中
-
找到当前结点的左子树,如果不为空,递归遍历左子树
-
找到当前结点的右子树,如果不为空,递归遍历右子树
-
-
代码实现
/**
* 前序遍历二叉树,返回key的队列
*
* @return
*/
public Queue<K> preErdogic() {
Queue<K> keys = new Queue<>();
preErdogic(root,keys);
return keys;
}
/**
* 前序遍历树x,把key放入keys中
*
* @param x
* @param keys
*/
private void preErdogic(Node x, Queue<K> keys) {
// x为空
if (x == null) {
return;
}
// x不为空
// 把x(即根)的key放入keys
keys.enQueue(x.key);
// 如果x的左子树不为空,递归调用
if (x.left != null) {
preErdogic(x.left, keys);
}
// 如果x的右子树不为空,递归调用
if (x.right != null) {
preErdogic(x.right, keys);
}
}
@Test
public void testPreErdogic() {
BinaryTree<String, String> bt = new BinaryTree<>();
bt.put("E", "5");
bt.put("B", "2");
bt.put("G", "7");
bt.put("A", "1");
bt.put("D", "4");
bt.put("F", "6");
bt.put("H", "8");
bt.put("C", "3");
Queue<String> keys = bt.preErdogic();
for (String k : keys) {
System.out.println(k + " -- " + bt.get(k));
}
}
E -- 5
B -- 2
A -- 1
D -- 4
C -- 3
G -- 7
F -- 6
H -- 8
2)中序遍历
中序遍历结果是有序的
-
在上图的树上,添加中序遍历的API:
public Queue<Key> midErgodic() // 使用中序遍历,获取整个树中的所有键 private void midErgodic(Node x,Queue<Key> keys) // 使用中序遍历,把指定树x中的所有键放入到keys队列中
-
实现步骤
-
找到当前结点的左子树,如果不为空,递归遍历左子树
-
把当前结点的key放入到队列中
-
找到当前结点的右子树,如果不为空,递归遍历右子树
-
-
代码实现
/**
* 中序遍历二叉树,返回key的队列
*
* @return
*/
public Queue<K> midErdogic() {
Queue<K> keys = new Queue<>();
midErdogic(root,keys);
return keys;
}
/**
* 中序遍历树x,把key放入keys中
*
* @param x
* @param keys
*/
private void midErdogic(Node x, Queue<K> keys) {
// x为空
if (x == null) {
return;
}
// x不为空
// 如果x的左子树不为空,递归调用
if (x.left != null) {
midErdogic(x.left, keys);
}
// 把x(即根)的key放入keys
keys.enQueue(x.key);
// 如果x的右子树不为空,递归调用
if (x.right != null) {
midErdogic(x.right, keys);
}
}
Queue<String> keys = bt.midErdogic();
// 中序遍历结果是有序的
A -- 1
B -- 2
C -- 3
D -- 4
E -- 5
F -- 6
G -- 7
H -- 8
3)后序遍历
-
在上图的树上,添加后序遍历的API:
public Queue<Key> afterErgodic() // 使用后序遍历,获取整个树中的所有键 private void afterErgodic(Node x,Queue<Key> keys) // 使用后序遍历,把指定树x中的所有键放入到keys队列中
-
实现步骤
-
找到当前结点的左子树,如果不为空,递归遍历左子树
-
找到当前结点的右子树,如果不为空,递归遍历右子树
-
把当前结点的key放入到队列中
-
-
代码实现
/**
* 后序遍历二叉树,返回key的队列
*
* @return
*/
public Queue<K> afterErdogic() {
Queue<K> keys = new Queue<>();
afterErdogic(root,keys);
return keys;
}
/**
* 后序遍历树x,把key放入keys中
*
* @param x
* @param keys
*/
private void afterErdogic(Node x, Queue<K> keys) {
// x为空
if (x == null) {
return;
}
// x不为空
// 如果x的左子树不为空,递归调用
if (x.left != null) {
afterErdogic(x.left, keys);
}
// 如果x的右子树不为空,递归调用
if (x.right != null) {
afterErdogic(x.right, keys);
}
// 把x(即根)的key放入keys
keys.enQueue(x.key);
}
Queue<String> keys = bt.afterErdogic();
A -- 1
C -- 3
D -- 4
B -- 2
F -- 6
H -- 8
G -- 7
E -- 5
7.5、二叉树的层序遍历
广度优先
所谓的层序遍历,就是从根节点(第一层)开始,依次向下, 获取每一层所有结点的值,有二叉树如下:
那么层序遍历的结果是:EBGADFHC
- 在上图的树上,添加层序遍历的API:
public Queue<Key> layerErgodic()// 使用层序遍历,获取整个树中的所有键
-
实现步骤
-
创建队列,存储每一层的结点
-
使用循环从 队列 中弹出一个结点
2.1 获取当前结点的key
2.2 如果当前结点的左子结点不为空,则把左子结点放入到队列中
2.3 如果当前结点的右子结点不为空,则把右子结点放入到队列中
-
- 代码实现
/**
* 层序遍历
*
* @return
*/
public Queue<K> layerErdogic() {
if (root == null) {
return null;
}
// 存结果keys
Queue<K> keys = new Queue<>();
// 辅助队列:每一个结点
Queue<Node> nodes = new Queue<>();
// 把根结点存入nodes
nodes.enQueue(root);
// 遍历
Node node;
while (!nodes.isEmpty()) {
// 从辅助队列中弹出一个元素node
node = nodes.deQueue();
// 把node的key存入keys
keys.enQueue(node.key);
// 判断node是否有左子结点,如果有,存入nodes
if (node.left != null) {
nodes.enQueue(node.left);
}
// 判断node是否有右子结点,如果有,存入nodes
if (node.right != null) {
nodes.enQueue(node.right);
}
}
return keys;
}
Queue<String> keys = bt.layerErdogic();
E -- 5
B -- 2
G -- 7
A -- 1
D -- 4
F -- 6
H -- 8
C -- 3
7.6、二叉树的最大深度问题
-
需求
给定一棵树,请计算树的最大深度(树的根节点到最远叶子结点的最长路径上的结点数)
下面这棵树的最大深度为4
-
API实现
public int maxDepth() // 计算整个树的最大深度
private int maxDepth(Node x) // 计算指定树x的最大深度
-
实现步骤
-
如果根结点为空,则最大深度为0
-
计算左子树的最大深度
-
计算右子树的最大深度
-
当前树的最大深度 = 左子树的最大深度 和 右子树的最大深度 中的 较大者 + 1
-
-
代码实现
/**
* 计算树的最大深度
*
* @return
*/
public int maxDepth() {
return maxDepth(root);
}
/**
* 计算树x的最大深度
* @param x
* @return
*/
private int maxDepth(Node x) {
if (x == null) {
return 0;
}
// 树的最大深度
int max = 0;
// 左子树的最大深度
int maxL = 0;
// 右子树的最大深度
int maxR = 0;
// 计算左子树的最大深度
if (x.left != null) {
maxL = maxDepth(x.left);
}
// 计算右子树的最大深度
if (x.right != null) {
maxR = maxDepth(x.right);
}
// 树的深度:左或右最大深度的较大量 + 1
max = maxL > maxR ? maxL + 1 : maxR + 1;
return max;
}
System.out.println(bt.maxDepth());
4
7.7、折纸问题
请把一段纸条竖着放在桌子上,然后从纸条的下边向上方对折1次,压出折痕后展开。此时 折痕是凹下去的,即折痕突起的方向指向纸条的背面。如果从纸条的下边向上方连续对折2次,压出折痕后展开,此时有三条折痕,从上到下依次是下折痕、下折痕和上折痕。
给定一 个输入参数N,代表纸条都从下边向上方连续对折N次,请从上到下打印所有折痕的方向。
例如:
N=1时,打印: down;
N=2时,打印: down down up
我们把对折后的纸张翻过来,让粉色朝下,这时把第一次对折产生的折痕看做是根结点,那第二次对折产生的下折痕就是该结点的左子结点,而第二次对折产生的上折痕就是该结点的右子结点,这样我们就可以使用树型数据结构来描述对折后产生的折痕
这棵树有这样的特点:
- 根结点为下折痕
- 每一个结点的左子结点为下折痕
- 每一个结点的右子结点为上折痕
- 实现步骤
- 定义结点类
- 构建深度为N的折痕树
- 使用中序遍历,打印出树中所有结点的内容
- 构建深度为N的折痕树
-
第一次对折,只有一条折痕,创建根结点
-
如果不是第一次对折,则使用队列保存根结点
-
循环遍历队列:
3.1 从队列中拿出一个结点
3.2 如果这个结点的左子结点不为空,则把这个左子结点添加到队列中
3.3 如果这个结点的右子结点不为空,则把这个右子结点添加到队列中
3.4 判断当前结点的左子结点和右子结点都不为空,如果是,则需要为当前结点创建一个值为down的左子结点,一个值为up的右子结点
- 代码实现
public class PaperFolding {
public static void main(String[] args) {
//构建折痕树
Node tree = createTree(3);
//遍历折痕树,并打印
printTree(tree);
}
//3.使用中序遍历,打印出树中所有结点的内容;
private static void printTree(Node tree) {
if (tree==null){
return;
}
printTree(tree.left);
System.out.print(tree.item+",");
printTree(tree.right);
}
//2.构建深度为N的折痕树;
private static Node createTree(int N) {
Node root = null;
for (int i = 0; i <N ; i++) {
if (i==0){
//1.第一次对折,只有一条折痕,创建根结点;
root = new Node("down",null,null);
}else{
//2.如果不是第一次对折,则使用队列保存根结点;
Queue<Node> queue = new Queue<>();
queue.enqueue(root);
//3.循环遍历队列:
while(!queue.isEmpty()){
//3.1从队列中拿出一个结点;
Node tmp = queue.dequeue();
//3.2如果这个结点的左子结点不为空,则把这个左子结点添加到队列中;
if (tmp.left!=null){
queue.enqueue(tmp.left);
}
//3.3如果这个结点的右子结点不为空,则把这个右子结点添加到队列中;
if (tmp.right!=null){
queue.enqueue(tmp.right);
}
//3.4判断当前结点的左子结点和右子结点都不为空,如果是,则需要为当前结点创建一个
值为down的左子结点,一个值为up的右子结点。
if (tmp.left==null && tmp.right==null){
tmp.left = new Node("down",null,null);
tmp.right = new Node("up",null,null);
}
}
}
}
return root;
}
//1.定义结点类
private static class Node{
//存储结点元素
String item;
//左子结点
Node left;
//右子结点
Node right;
public Node(String item, Node left, Node right){
this.item = item;
this.left = left;
this.right = right;
}
}
}