【数据结构与算法】二叉树

最新推荐文章于 2024-09-04 20:32:35 发布

Redamancy丶早晚

最新推荐文章于 2024-09-04 20:32:35 发布

阅读量614

点赞数 22

分类专栏：数据结构文章标签：数据结构算法

本文链接：https://blog.csdn.net/m0_67660672/article/details/134019172

版权

数据结构专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一. 树型结构

1.1 概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

有一个特殊的结点，称为根结点，根结点没有前驱结点
除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合 Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
树是递归定义的。

在这里插入图片描述

其中红色部分就是子树，枝干之间不能相交

注意：树形结构中，子树之间不能有交集，否则就不是树形结构

子树是不相交的
除了根结点外，每个结点有且仅有一个父结点
一棵 N 个结点的树有N-1条边。

1.2 概念

在这里插入图片描述

结点的度：一个结点含有子树的个数称为该结点的度；如上图：A的度为6
树的度：一棵树中，所有结点度的最大值称为树的度；如上图：树的度为6
叶子结点或终端结点：度为0的结点称为叶结点；如上图：B、C、H、I…等节点为叶结点
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；如上图：B是A的孩子结点
根结点：一棵树中，没有双亲结点的结点；如上图：A
结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推
树的高度或深度：树中结点的最大层次；如上图：树的高度为4。（深度是每一层的深度，可以变化）

树的以下概念只需了解，在看书时只要知道是什么意思即可：

非终端结点或分支结点：度不为0的结点；如上图：D、E、F、G…等节点为分支结点
兄弟结点：具有相同父结点的结点互称为兄弟结点；如上图：B、C是兄弟结点
堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
森林：由m（m>=0）棵互不相交的树组成的集合称为森林

1.3 树的表示形式

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，如：双亲表示法，孩子表示法、孩子双亲表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

class Node {
	int value; // 树中存储的数据
	Node firstChild; // 第一个孩子引用
	Node nextBrother; // 下一个兄弟引用
}

在这里插入图片描述

1.4 树的应用

文件系统管理（目录和文件）

在这里插入图片描述

二.二叉树

2.1 概念

一棵二叉树是结点的一个有限集合，该集合：

或者为空
或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。

在这里插入图片描述

从上图可以看出：

二叉树不存在度大于2的结点
二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

注意：对于任意的二叉树都是由以下几种情况复合而成的：

在这里插入图片描述

2.2 两种特殊的二叉树

满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵二叉树的层数为K，且结点总数是 2^k - 1 ，则它就是满二叉树。
完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为 K 的，有 n 个结点的二叉树，当且仅当其每一个结点都与深度为 K 的满二叉树中编号从 0 至 n-1 的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。（从左到右依次存放的）

在这里插入图片描述

2.3 二叉树的性质

若规定根结点的层数为 1，则一棵非空二叉树的第i层上最多有 2^(i - 1) (i>0) 个结点
若规定只有根结点的二叉树的深度为 1，则深度为K的二叉树的最大结点数是 2^k -1 (k>=0)
对任何一棵二叉树，如果其叶结点个数为 n0，度为2的非叶结点个数为 n2，则有 n0 ＝n2＋1。

在这里插入图片描述

具有 n 个结点的完全二叉树的深度k为 log_2 (n+1)上取整
对于具有 n 个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为 i 的结点有：

若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
若2i+1<n，左孩子序号：2i+1，否则无左孩子
若2i+2<n，右孩子序号：2i+2，否则无右孩子

已知孩子节点下标设为 i，双亲节点的下标：（i-1）/ 2
已知父亲节点下标为 i，左孩子：2i +1；右孩子：2i + 2

在这里插入图片描述

我们知道因为 2n 肯定是偶数，所以在偶数个完全二叉树中，n0 代表度为 0 的节点，n1 代表度为 1 的节点，n2 代表度为 2 的节点，根据公式三 n0 = n2 + 1，然后偶数个完全二叉树中 n1 = 1，所以列等式可以知道 2n = n0 + n1 + n2 => n = n0，选 A。

在这里插入图片描述

根据上面的推导选 B

2.4 二叉树的存储

二叉树的存储结构分为：顺序存储（堆）和类似于链表的链式存储。

二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式，具体如下：

// 孩子表示法
class Node {
	int val; // 数据域
	Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
	Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}

// 孩子双亲表示法
class Node {
	int val; // 数据域
	Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
	Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
	Node parent; // 当前节点的根节点
}

在这里插入图片描述

2.5 二叉树的基本操作

2.5.1 前置说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

在这里插入图片描述

2.5.2 二叉树的遍历

1. 前序遍历

根 --> 左 --> 右

在这里插入图片描述

A B D C E F

2. 中序遍历

左 --> 根 --> 右

在这里插入图片描述

D B A E C F

3. 后序遍历

左 --> 右 --> 根

在这里插入图片描述

D B E F C A

在这里插入图片描述

4. 层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

在这里插入图片描述

不能根据前序和后序遍历创建一颗二叉树，只能确定一个根节点，无法确定左右树

2.5.3 前中后三种遍历实现方式：

在这里插入图片描述

1. 二叉树前序递归遍历实现

方式一：

在这里插入图片描述

方式二：

在这里插入图片描述

2.二叉树中序递归遍历实现

在这里插入图片描述

3.二叉树后序递归遍历实现

在这里插入图片描述

4.获取树中节点的个数

两种方法，一种遍历思路，一种子问题思路

遍历思路

在这里插入图片描述

子问题

分割成左树和右树和根

在这里插入图片描述

5.获取叶子节点的个数

遍历思路

在这里插入图片描述

子问题思路

左树叶子加右树叶子就是整棵树叶子

在这里插入图片描述

6.获取第K层节点的个数

相当于左树加右树的节点数加上第一层的根

在这里插入图片描述

7.获取二叉树的高度

左树和右树高度的最大值 + 1

在这里插入图片描述

8.检测值为value的元素是否存在

先查找根节点
左子树查找
右子树查找

在这里插入图片描述

9.层序遍历

在这里插入图片描述

设置一个 cur 接收队列弹出的元素

分每一层的层序遍历

在这里插入图片描述

每一层的元素都分出开来了

在这里插入图片描述

所以可以延伸很多题目，例如左视图是哪几个，右视图是哪几个，每一层有多少个元素…

10.判断一棵树是不是完全二叉树

在这里插入图片描述

把每一个元素都调进队列里，然后又排出去，最后看队列是不是只剩下 null 从而判定是不是完全二叉树

2.6 二叉树相关oj题

1. 检查两颗树是否相同

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

在这里插入图片描述

public boolean isSameTree(TreeNode p, TreeNode q) {
    if(p == null && q != null) return false;
    if(p != null && q == null) return false;
    //要么两个都是空 要么两个都不为空
    if(p == null && q == null) return true;
    //两个都不为空
    if(p.val != q.val) return false;
    //两个都不为空且两个节点的值一样
    return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}

2.另一颗树的子树

你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

在这里插入图片描述

判断 subRoot 是不是和 root 是相同的两棵树
判断 subRoot 是不是 root 的左树的子树
判断 subRoot 是不是 root 的右树的子树

在这里插入图片描述

3.二叉树最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。

在这里插入图片描述

4.判断一颗二叉树是否是平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1 。

要是一棵树是高度平衡的二叉树，那么这颗树的每个子树都是高度平衡的。

在这里插入图片描述

还有更好的方案就是在求高度的时候就遍历查找然后时间复杂度就只有 O(n)

在这里插入图片描述

5.对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称

在这里插入图片描述

6.二叉树的构建及遍历

描述：

编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。例如如下的先序遍历字符串： ABC##DE#G##F### 其中 “#” 表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

在这里插入图片描述

7.给定一个二叉树, 找到该树中两个指定节点的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

思路一：

1、使用2个栈，存储从根节点到指定的节点的路径上的所有节点
2、比较两个栈的大小，让栈中多的出差值个
3、此时同时开始出栈，如果栈顶元素相同，那么此时这个值就是最近公共祖先

在这里插入图片描述

思路二：

如果是一颗二叉搜索树（二叉搜索树的定义就是根节点左边的值肯定小于根根节点右边的值肯定大于根）

p 或 q 一个比 root 根节点大一个比它小，那么 p 和 q 分别在根节点左右两侧，最近公共祖先就是 root
p 或 q 其中有一个等于根节点 root 的话，那么最近公共祖先就是 p 或 q
p 或 q 都小于或者都大于根节点 root 的话，那么 p 和 q 都在左一侧或者右一侧，再分别递归

在这里插入图片描述

8.二叉树搜索树转换成排序双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。如下图所示

在这里插入图片描述

确定顺序就是中序遍历

在这里插入图片描述

9.根据一棵树的前序遍历与中序遍历构造二叉树

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

在这里插入图片描述

思路：
1、定义prelndex遍历前序遍历这个数组
2、在中序遍历的ib-ie，找到ri的下标位置
3、此时ri左边的就是左树，ri右边的就是右树
4、递归创建左树和递归创建右树
5、当ib > ie的时候，说明没有了左树或者右树

public int preIndex = 0;
    public TreeNode buildTreeChild(int[] preorder, int[] inorder,int inbegin,int inend) {
        if(inbegin > inend) return null;//说明此时，没有左树或者右树

        TreeNode root = new TreeNode(preorder[preIndex]);

        //1、找到根节点在中序遍历当中的位置
        int rootIndex = findInorderRootIndex(inorder,inbegin,inend,preorder[preIndex]);
        preIndex++;

        root.left = buildTreeChild(preorder,inorder,inbegin,rootIndex-1);
        root.right = buildTreeChild(preorder,inorder,rootIndex+1,inend);

        return root;

    }

    private int findInorderRootIndex(int[] inorder,int inbegin,int inend,int val) {
        for(int i = inbegin;i <= inend;i++) {
            if(inorder[i] == val) {
                return i;
            }
        }
        return -1;//没有val这个数据
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return buildTreeChild(preorder,inorder,0,inorder.length-1);
    }

10.从中序与后序遍历序列构造二叉树

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗二叉树。

和上面一题目思路一样：

public int postIndex = 0;
    public TreeNode buildTreeChild(int[] postorder, int[] inorder,int inbegin,int inend) {
        if(inbegin > inend) return null;//说明此时，没有左树或者右树

        TreeNode root = new TreeNode(postorder[postIndex]);

        //1、找到根节点在中序遍历当中的位置
        int rootIndex = findInorderRootIndex(inorder,inbegin,inend,postorder[postIndex]);
        postIndex--;

        root.right = buildTreeChild(postorder,inorder,rootIndex+1,inend);
        root.left = buildTreeChild(postorder,inorder,inbegin,rootIndex-1);

        return root;

    }

    private int findInorderRootIndex(int[] inorder,int inbegin,int inend,int val) {
        for(int i = inbegin;i <= inend;i++) {
            if(inorder[i] == val) {
                return i;
            }
        }
        return -1;//没有val这个数据
    }
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        postIndex = postorder.length-1;
        return buildTreeChild(postorder,inorder,0,inorder.length-1);
    }

11.根据二叉树创建字符串

给你二叉树的根节点 root ，请你采用前序遍历的方式，将二叉树转化为一个由括号和整数组成的字符串，返回构造出的字符串。

空节点使用一对空括号对 “()” 表示，转化后需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。

在这里插入图片描述

思路：

根据示例，可以总结以下规律

左树不为空 + (，递归左树，当左树全部走完 + )
右树不为空 + (，递归右树，当右树全部走完 + )
左树不为空，左右树都为空，就什么都不做
左树为空，右树不为空 + ()

public void tree2strChild(TreeNode t, StringBuilder sb) {
        if (t == null) return;
        sb.append(t.val);

        if (t.left != null) {
            sb.append("(");
            tree2strChild(t.left, sb);
            sb.append(")");
        } else {
            if (t.right == null) {
                return;
            } else {
                sb.append("()");
            }
        }

        if (t.right == null) {
            return;
        } else {
            sb.append("(");
            tree2strChild(t.right, sb);
            sb.append(")");
        }
    }

    public String tree2str(TreeNode root) {
        if (root == null) return null;

        StringBuilder sb = new StringBuilder();
        tree2strChild(root, sb);

        return sb.toString();
    }

12.二叉树前序非递归遍历实现

给你二叉树的根节点 root ，返回它节点值的前序遍历。

思路：

root节点不动，定义一个 cur 节点进行前序遍历，然后当 cur 走的时候存储每个节点到栈里面，并且把节点对应的值添加到 list 集合里，每当 cur 为空的时候就可以弹出栈顶元素，让 cur 走栈顶元素进行右边树的遍历

public List<Character> preorderTraversalNor(TreeNode root) {
    List<Character> list = new ArrayList<>();
    if (root == null) return list;

    Stack<TreeNode> stack = new Stack<>();

    TreeNode cur = root;
    //这里是一个难点，需要倒回来写这个循环
    while (cur != null || !stack.empty()) {
        while (cur != null) {
            stack.push(cur);
            list.add(cur.val);//打印
            cur = cur.left;
        }
        TreeNode top = stack.pop();
        cur = top.right;
    }
    return list;
}

13.二叉树中序非递归遍历实现

给定一个二叉树的根节点 root ，返回它的中序遍历。

思路：

和前序遍历差不多

public List<Character> inorderTraversalNor(TreeNode root) {
    List<Character> list = new ArrayList<>();
    if (root == null) return list;

    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;

    while (cur != null || !stack.empty()) {
        while (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }
        TreeNode top = stack.pop();
        list.add(top.val);
        cur = top.right;
    }
    return list;
}

14.二叉树后序非递归遍历实现

给你一棵二叉树的根节点 root ，返回其节点值的后序遍历。

思路：

和前面两个差不多，主要是要注意节点的打印，例如当我们节点没有左树，有右树的时候，当我们程序运行的时候，得记录一下右树是走过的，用 prev 标记一下，不然当回到节点，又会死循环到我们的右树

public List<Character> postorderTraversalNor(TreeNode root) {
    List<Character> list = new ArrayList<>();
    if (root == null) return list;
    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;
    TreeNode prev = null;
    while (cur != null || !stack.empty()) {
        while (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }
        TreeNode top = stack.peek();
        if (top.right == null || top.right == prev) {
            stack.pop();
            list.add(top.val);
            prev = top;
        } else {
            cur = top.right;
        }
    }
    return list;
}