文章目录
- 树
- 树的定义：
- 关于树的相关概念：
- 树的实际实现形式（表现形式）
- 树的应用
- 二叉树
- 二叉树的概念
- 特殊的二叉树
- 二叉树的性质：
- 二叉树的存储实现：
- 二叉树的模拟实现：
- 实现的成员方法与属性：
- 实现节点内部类：
- 二叉树的遍历：
- 获取节点的个数
- 获取叶子节点的个数
- 获取第k层节点的个数
- 获取二叉树的高度
- 检查值为value的元素是否存在
- 判断一棵树是否是完全二叉树
- 二叉树相关的oj题
- 相同的树
- 判断本树是否包含与另一棵树相同的子树
- 翻转二叉树
- 判断一棵二叉树是否是平衡二叉树
- 对称二叉树
- 二叉树的构建与遍历
- 二叉树的分层遍历
树
在学习二叉树之前，先学习一下树的概念
树的定义：
树是一种数据结构，对比于生活中常见的树，其逻辑结构是倒立着的:
如图：
- 树是由n个节点组成的有限集，（当n==0时，称此树为空树），对于任何一棵非空树，只有唯一的根节点root.
- 当n>1时，除去根节点，剩余节点可以分为m个有限集（m>0),这些有限集互不相交，其中每个集合又是一棵树，称为根的子树。
关于树的相关概念：
树的实际实现形式（表现形式）
树结构相对于线性表比较复杂，要存储表示起来比较麻烦，有许多种表示方法，如：双亲表示法，孩子表示法，孩子双亲表示法，孩子兄弟表示法等等。
这里只介绍一下孩子兄弟表示法。
孩子兄弟表示法：
孩子兄弟表示法的思想是使得为每一个节点创建两个指针，一个指针指向此节点的第一个孩子节点
另一个指针指向此节点的兄弟节点，对于此节点的其他孩子节点则通过孩子节点的兄弟指针指向。
如图：
树的应用
我们电脑中的文件系统所采取的即树的思想：
二叉树
二叉树的概念
二叉树是一种特殊的树，与其它树不同的特性在于每一个节点最多有两个子节点。每一个节点的左树称为该节点的左子树，右树称为右子树，即：
从上图可以看出：
- 二叉树不存在度大于2的结点
- 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。
特殊的二叉树
有两种特殊的二叉树，满二叉树与完全二叉树
- 满二叉树是指如果二叉树的每层节点数都达到最大值，称此二叉树为满二叉树。
如图：
- 完全二叉树是指对于一棵二叉树，其节点是根据从上到下，从左到右顺序排列的。
注：由两种特殊的二叉树性质可知，满二叉树是一种特殊的完全二叉树。
二叉树的性质：
这些二叉树的性质与算法设计紧密联系，应该熟练掌握。
- 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 2^(i - 1)(i>0)个结点。
- 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是2^k-1 (k>=0)。
- 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1。
这条性质我们需要推导一下。
- 具有N个结点的完全二叉树的深度k为log(N+1)以2为底向上取整。
解：只有完全二叉树才可以根据节点个数推导二叉树的深度，推导过程：
比如下面的这棵二叉树，log2(13+1) 取整，结果为4
- 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则 对于序号为i的结点有：
若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点；
若2i+1<n，左孩子序号：2i+1，否则无左孩子；
若2i+2<n，右孩子序号：2i+2，否则无右孩子。
二叉树的存储实现：
二叉树的存储实现有两种情况，一种是顺序存储（在下节堆中讲到），另一种是链式存储
二叉树的链式存储是将节点都一个个连接起来，有两个引用与三个引用的情况：
// 孩子表示法
class Node {
int val; // 数据域
Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}
// 孩子双亲表示法
class Node {
int val; // 数据域
Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
Node parent; // 当前节点的双亲节点
}
二叉树的模拟实现：
实现的成员方法与属性：
public class BinaryTree {
// 前序遍历
public void preOrder(TreeNode root) {}
// 中序遍历
void inOrder(TreeNode root) {}
// 后序遍历
void postOrder(TreeNode root) {}
// 获取节点的个数
int size2(TreeNode root) {}
//获取叶子节点的个数
int getLeafNodeCount2(TreeNode root) {}
//获取第K层节点的个数
int getKLevelNodeCount(TreeNode root, int k) {}
//获取二叉树的高度 时间复杂度：O(N)
int getHeight(TreeNode root) {}
// 检测值为value的元素是否存在
TreeNode find(TreeNode root, char val) {}
//层序遍历
void levelOrder(TreeNode root) {}
// 判断一棵树是不是完全二叉树
boolean isCompleteTree(TreeNode root) {}
}
实现节点内部类：
static class TreeNode {
public char val;
public TreeNode left;//左孩子的引用
public TreeNode right;//右孩子的引用
public TreeNode(char val) {
this.val = val;
}
}
二叉树的遍历：
遍历二叉树有四种方式，分别是前序遍历，中序遍历，后序遍历，层序遍历
前序遍历是按照先根节点，然后左节点，然后右节点
中序遍历是先左节点，后根节点，然后右节点
后序遍历是先左节点，后右节点，然后根节点
二叉树不一定只有三个节点，所以这涉及递归的思想，在树的定义中，根节点的左节点即是左子树的根节点，这包含了递归的思想，所以二叉树的三种遍历可以通过递归的方式实现：
层序遍历即按照从上到下，从左到右，每一层地遍历二叉树。
前序遍历：
实现思想：遍历到当前节点时，先判断当前节点是否为空，不为空则打印此节点的数值，
并递归到本节点的左节点与右节点中去。
// 前序遍历
public void preOrder(TreeNode root) {
if (root == null) return;
System.out.print(root.val + " ");
preOrder(root.left);
preOrder(root.right);
}
中序遍历：
实现思想：遍历到当前节点时，判断当前节点是否为空，不为空，则先递归到当前节点的左节点中去，从左节点的方法返回时，再打印当前节点，然后再递归到右节点中去。
// 中序遍历
void inOrder(TreeNode root) {
if (root == null) return;
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
后序遍历
实现思想：遍历到当前节点时，判断当前节点是否为空，不为空，则先递归到当前节点的左节点中去，从左节点的方法返回时，再递归到右节点中去，当从左节点的方法与右节点的方法返回时，打印
根节点数值。
// 后序遍历
void postOrder(TreeNode root) {
if (root == null) return;
postOrder(root.left);
postOrder(root.right);
System.out.print(root.val + " ");
}
层序遍历：
问题： 如何找到当前节点的兄弟节点，并且能够返回到当前层的第一个节点的左节点，递归的思想实现不了，我们需要一个新的数据结构，能够储存节点。
实现思想：
进行层序遍历时，我们要用到队列（先进先出）这个数据结构，
从根结点开始先放进队列去。
然后将队列中节点取出打印，如果此节点的左右节点不为空，则将左右节点放入队列中，然后再循环往复，直到队列为空为止。
//层序遍历
void levelOrder(TreeNode root) {
if (root == null) return;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode cur = queue.poll();
System.out.print(cur.val + " ");
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
}
}
获取节点的个数
实现思想：采用递归的思想，左子树节点个数+右子树节点个数+1，如果此节点为空，返回0.
int size2(TreeNode root) {
if (root == null) return 0;
return size2(root.left)
+ size2(root.right) + 1;
}
获取叶子节点的个数
获取叶子节点的个数
实现思想：
采用递归的思想
如果树为空，返回0。
不为空，如果节点左子树和右子树为空则返回1。
最后返回根节点左子树和右子树的叶子结点之和。
int getLeafNodeCount2(TreeNode root) {
if (root == null) return 0;
if (root.left == null && root.right == null) {
return 1;
}
return getLeafNodeCount2(root.left) + getLeafNodeCount2(root.right);
}
获取第k层节点的个数
思想：获取二叉树第k层的节点相当于获取其子树的k-1层节点，以此递归直至k=1.
实现思想：
- 如果树为空，返回0。
- 不为空，如果层数为1并且该节点不为空则返回1。（如果k为1，且此节点存在，则此树的节点即此节点为1）
- 最后返回根节点左子树和右子树的第k-1层结点之和。
int getKLevelNodeCount(TreeNode root, int k) {
if (root == null) return 0;
if (k == 1) return 1;
return getKLevelNodeCount(root.left, k - 1) +
getKLevelNodeCount(root.right, k - 1);
}
获取二叉树的高度
实现思想：通过递归思想，获取左子树高度与右子树高度，取两者最大值然后+1
int getHeight(TreeNode root) {
if (root == null) return 0;
int leftH = getHeight(root.left);
int rightH = getHeight(root.right);
return leftH > rightH ? leftH + 1 : rightH + 1;
}
检查值为value的元素是否存在
public TreeNode contains(TreeNode root , int val){
//采用前序遍历
if(root == null){
return null;
}
if(root.val == val){
return root;
}
TreeNode b1 = contains(root.left);
if(b1!=null){
return b1;
}
TreeNode b2 = contains(root.right);
if(b2!=null){
return b2;
}
return null;
}
判断一棵树是否是完全二叉树
实现思想：
在之前层序遍历的实现算法中，我们采用了一个新的数据结构，将每一个节点的非空子节点存储至队列中，对于判断完全二叉树，也可以通过一个队列，将遍历到的节点的左节点与右节点均放入队列中，无论其是否为空节点，然后将队列中的全部数据输出，如果发现空节点之后，还有数据说明此树非完全二叉树，没有，则说明此树为完全二叉树。
具体实现思想：
- 如果根节点为空直接返回false。
- 不为空将根放入队列。
- 取出队列值，如果值不为空就将左孩子和右孩子（孩子是否为空不影响入队）入队，为空直接出循环。
- 因为前面是拿到队列中的空节点出循环的，遍历剩余节点如果遇到不为空的节点那该树就不是完全二叉树。
boolean isCompleteTree(TreeNode root) {
if (root == null) return false;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode cur = queue.poll();
if (cur != null) {
queue.offer(cur.left);
queue.offer(cur.right);
} else {
break;
}
}
//第2次遍历队列 判断队列当中 是否存在非空的元素
while(!queue.isEmpty()) {
TreeNode cur = queue.peek();
if (cur == null) {
queue.poll();
} else {
return false;
}
}
return true;
}
}
二叉树相关的oj题
相同的树
实现思想：采用递归的思想，判断左子树与左子树相同，右子树与右子树相同，两个根节点也相同。
class Solution {
public boolean isSameTree(TreeNode p, TreeNode q) {
if(p ==null&&q==null){
return true;
}
//此时设计判断条件是为了下一条件避免空指针异常
if((p !=null && q== null)||(p==null&&q!=null)){
return false;
}
if(isSameTree(p.left,q.left)&&isSameTree(p.right,q.right)&&(p.val==q.val)){
return true;
}
return false;
}
}
判断本树是否包含与另一棵树相同的子树
实现思想：遍历本树的每一个节点，然后以当前节点作为根节点判断与另一棵树是否相同
需要创建两个方法。一个用于遍历，一个用于比较。
class Solution {
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
//遍历整个二叉树，按照前序遍历的方式
if(root == null){
return false;
}
boolean b1 = isSameTree(root,subRoot);
if(b1 ==true){
return true;
}
boolean b2 = isSubtree(root.left,subRoot);
if(b2 == true){
return true;
}
boolean b3 = isSubtree(root.right,subRoot);
if(b3 ==true){
return true;
}
return false;
}
public boolean isSameTree(TreeNode p, TreeNode q) {
if(p ==null&&q==null){
return true;
}
//此时设计判断条件是为了下一条件避免空指针异常
if((p !=null && q== null)||(p==null&&q!=null)){
return false;
}
if(isSameTree(p.left,q.left)&&isSameTree(p.right,q.right)&&(p.val==q.val)){
return true;
}
return false;
}
}
翻转二叉树
实现思想：采用递归的思想，将每一个节点的左节点与右节点相互交换
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null){
return null;
}
TreeNode cur = root.left;
root.left = root.right;
root.right = cur;
//将左子树与右子树，依次翻转
invertTree(root.left);
invertTree(root.right);
return root;
}
}
判断一棵二叉树是否是平衡二叉树
实现思想：在获取二叉树的高度的方法中，获取每一个节点的左子树高度与右子树高度之差，如果绝对值中出现大于的情况，返回-1 。
class Solution {
public boolean isBalanced(TreeNode root) {
return isBalanced2(root)!=-1;
}
public int isBalanced2(TreeNode root){
if(root == null){
return 0;
}
int leftHeight = isBalanced2(root.left);
if(leftHeight == -1){
return -1;
}
int rightHeight = isBalanced2(root.right);
if(rightHeight == -1){
return -1;
}
if(Math.abs(leftHeight-rightHeight)>1){
return -1;
}
return leftHeight>rightHeight ? leftHeight+1:rightHeight+1;
}
}
对称二叉树
实现思想：通过递归的思想，判断根节点的左节点的左子树与右节点的右子树，左节点的右子树与右节点的左子树是否相同。
class Solution {
public boolean isSymmetric(TreeNode root) {
return isSymmetric2(root.left,root.right);
}
public boolean isSymmetric2(TreeNode r1 , TreeNode r2){
if(r1 == null&&r2 == null){
return true;
}
if( ( r1!= null&&r2 ==null)|| (r1==null&&r2!=null) ){
return false;
}
if(r1.val ==r2.val&& isSymmetric2(r1.left,r2.right)&&isSymmetric2(r1.right,r2.left)){
return true ;
}
return false;
}
}
二叉树的构建与遍历
实现思想：通过递归算法，按照前序遍历的顺序进行节点创建并赋值，如果遇到#则跳过。
import java.util.Scanner;
class TreeNode {
public TreeNode left;
public TreeNode right;
public char val;
public TreeNode(char val) {
this.val = val;
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextLine()) { // 注意 while 处理多个 case
String str = in.nextLine();
TreeNode cur = createtree(str);
inOrder(cur);
}
}
public static int i;
public static TreeNode createtree(String str) {
//开始创建
TreeNode root = null;
if (str.charAt(i) != '#') {
root = new TreeNode(str.charAt(i));
i++;
root.left = createtree(str);
root.right = createtree(str);
} else {
i++;
}
return root;
}
public static void inOrder(TreeNode root) {
if (root == null) {
return;
}
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
}
二叉树的分层遍历
实现思想：在之前的层序遍历中，我们是将在将每一个节点从队列中出去时，并将此节点的非空子节点输入到队列中，但是在本题中我们需要区分每一层之间的节点
- 所以在输入完一层的节点后，我们需要先判断当前队列中的节点数量
- 然后以此作为判断条件循环将当前队列中的值，输入到一个新的数组中去，并且将每一个节点的非空子节点输入到队列中去，将新的数组输入到二维数组中去。
- 循环往复，直到队列为空。
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> list1 = new ArrayList<>();
if(root == null){
return list1;
}
LinkedList <TreeNode> queue = new LinkedList(); //创建队列
queue.offer(root);
while (!queue.isEmpty()) {
//打印队列中的节点
//先获取队列中上一层节点的个数
int len = queue.size();
List<Integer>list2 = new ArrayList<>();
while(len>=1){
//将队列1中队出的数据存入队列2中
TreeNode cur = queue.poll();
list2.add(cur.val);
//然后将本节点左节点与右节点放入队列1中
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
//最后将当前数组中的内容加入到二维数组中去
len--;
}
list1.add(list2);
}
return list1;
}
}
![[Spring] SpringBoot统一功能处理与图书管理系统](https://i-blog.csdnimg.cn/direct/3e5d61d075e145db9ec359b0284a9406.png)
