【数据结构】树_一棵树有最多有多少个联通块-博客园-优快云博客

本文链接：https://blog.youkuaiyun.com/suiyishiguang/article/details/136843791

本文围绕树和二叉树的数据结构展开。介绍了树的概念、遍历、存储结构，对比了数组、链式和树存储方式的优缺点。详细阐述了二叉树的定义、形态、存储、遍历，还包括二叉树的查找、删除操作，以及顺序存储和线索化二叉树的相关内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

一：树
二：二叉树
三：二叉树遍历、查找、删除
四：二叉树的顺序存储
五：线索化二叉树

一：树

1.1 概念

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

根结点：根节点没有前驱结点。
除根节点外，其余结点被分成是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
因此，树是递归定义的。

1.2 定义

树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足：

有且仅有一个特定的称为根的结点。
当n>1时，其余节点可分为m（m>0）个互不相交的有限集T1,T2,…,Tm，其中每个集合本身又是一棵树，并且称为根的子树。

显然，树的定义是递归的，即在树的定义中又用到了自身，树是一种递归的数据结构。树作为一种逻辑结构，同时也是一种分层结构，具有以下两个特点：

树的根结点没有前驱，除根结点外的所有结点有且只有一个前驱。
树中所有结点可以有零个或多个后继。因此n个结点的树中有n-1条边。

1.3 基本术语

在这里插入图片描述

节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为2
叶节点：度为0的节点称为叶节点；如上图：G、H、I节点为叶节点
非终端节点或分支节点：度不为0的节点；如上图：B、D、C、E、F节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为2
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；如上图：树的高度为4
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m棵互不相交的树的集合称为森林；

1.4 树的遍历

遍历表达法有4种方法：先序遍历（前序遍历）、中序遍历、后序遍历、层次遍历。
在这里插入图片描述

先序遍历：对树按照根、左、右的规律进行访问。上图的遍历结果为ABCDEFG。
中序遍历：对树按照左、根、右的规律进行访问。上图的遍历结果为DBAGECF。
后序遍历：对树按照左、右、根的规律进行访问。上图的遍历结果为DBGEFCA。
层次遍历：对树按照从上到下、从左到右的规律进行访问。上图的遍历结果为ABCDEFG。

1.5 存储结构

由于树中每个结点的孩子可以有多个，所以简单的顺序存储结构无法满足树的实现要求。下面介绍三种常用的表示树的方法：双亲表示法、孩子表示法和孩子兄弟表示法。

1.5.1 双亲表示法

由于树中每个结点都仅有一个双亲结点（根节点没有），我们可以使用指向双亲结点的指针来表示树中结点的关系。这种表示法有点类似于前面介绍的静态链表的表示方法。具体做法是以一组连续空间存储树的结点，同时在每个结点中，设一个「游标」指向其双亲结点在数组中的位置。代码如下：

public class PTree<E> {
   
    private static final int DEFAULT_CAPACITY = 100;
    private int size;
    private Node[] nodes;

    private class Node() {
   
        E data;
        int parent;

        Node(E data, int parent) {
   
            this.data = data;
            this.parent = parent;
        }
    }

    public PTree() {
   
        nodes = new PTree.Node[DEFAULT_CAPACITY];
    }
}

由于根结点没有双亲结点，我们约定根节点的parent域值为-1。树的双亲表示法如下所示：
在这里插入图片描述
这样的存储结构，我们可以根据结点的parent域在O(1)的时间找到其双亲结点，但是只能通过遍历整棵树才能找到它的孩子结点。一种解决办法是在结点结构中增加其孩子结点的域，但若结点的孩子结点很多，结点结构将会变的很复杂。

1.5.2 孩子表示法

由于树中每个结点可能有多个孩子，可以考虑用多重链表，即每个结点有多个指针域，每个指针指向一个孩子结点，我们把这种方法叫多重链表表示法。它有两种设计方案：
方案一：指针域的个数等于树的度。其结点结构可以表示为：

class Node() {
   
    E data;
    Node child1;
    Node child2;
    ...
    Node childn;
}

对于上一节中的树，树的度为3，其实现为：

在这里插入图片描述

显然，当树中各结点的度相差很大时，这种方法对空间有很大的浪费。

方案二，每个结点指针域的个数等于该结点的度，取一个位置来存储结点指针的个数。其结点结构可以表示为：

class Node() {
   
    E data;
    int degree;
    Node[] nodes;
    Node(int degree) {
   
        this.degree = degree;
        nodes = new Node[degree];
    }
}

对于上一节中的树，这种方法的实现为：

这种方法克服了浪费空间的缺点，但由于各结点结构不同，在运算上会带来时间上的损耗。

为了减少空指针的浪费，同时又使结点相同。我们可以将顺序存储结构和链式存储结构相结合。具体做法是：把每个结点的孩子结点以单链表的形式链接起来，若是叶子结点则此单链表为空。然后将所有链表存放进一个一维数组中。这种表示方法被称为孩子表示法。其结构为：
在这里插入图片描述
代码表示：

public class CTree<E> {
   
    private static final int DEFAULT_CAPACITY = 100;
    private int size;
    private Node[] nodes;

    private class Node() {
   
        E data;
        ChildNode firstChild;
    }
    
    //链表结点
    private class ChildNode() {
   
        int cur; //存放结点在nodes数组中的下标
        ChildNode next;
    }

    public CTree() {
   
        nodes = new CTree.Node[DEFAULT_CAPACITY];
    }
}

这种结构对于查找某个结点的孩子结点比较容易，但若想要查找它的双亲或兄弟，则需要遍历整棵树，比较麻烦。可以将双亲表示法和孩子表示法相结合，这种方法被称为双亲孩子表示法。其结构如下：
在这里插入图片描述
其代码和孩子表示法的基本相同，只需在Node结点中增加parent域即可。

1.5.3 孩子兄弟表示法

任意一棵树，它的结点的第一个孩子如果存在则是唯一的，它的右兄弟如果存在也是唯一的。因此，我们可以使用两个分别指向该结点的第一个孩子和右兄弟的指针来表示一颗树。其结点结构为：

class Node() {
   
    E data;
    Node firstChild;
    Node rightSib;
}

其结构如下：
在这里插入图片描述
这个方法，可以方便的查找到某个结点的孩子，只需先通过firstChild找到它的第一个孩子，然后通过rightSib找到它的第二个孩子，接着一直下去，直到找到想要的孩子。若要查找某个结点的双亲和左兄弟，使用这个方法则比较麻烦。

这个方法最大的好处是将一颗复杂的树变成了一颗二叉树。这样就可以使用二叉树的一些特性和算法了。

1.6 为什么需要树这种数据结构

1.6.1 数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。
缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低

1.6.2 链式存储方式的分析

优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很好)。
缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)

1.6.3 树存储方式的分析

能提高数据存储，读取的效率, 比如利用二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度

二：二叉树

2.1 定义

二叉树(Binary Tree) 是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树T：

有且仅有一个根结点；
除根结点外的其余结点又可分为两个不相交的子集TL和TR ，分别称为T的左子树和右子树，且TL 和TR本身又都是二叉树。

很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；二是结点的子树有左右之分，不能随意调换，调换后又是一棵新的二叉树。

2.2 形态

2.2.1 五种基本形态

从上面二叉树的递归定义可以看出，二叉树或为空，或为一个根结点加上两棵左右子树，因为两棵左右子树也是二叉树也可以为空，所以二叉树有5种基本形态：
在这里插入图片描述

2.2.2 三种特殊形态

在这里插入图片描述

2.3 存储

存的目的是为了取，而取的关键在于如何通过父结点拿到它的左右子结点，不同存储方式围绕的核心也就是这。

2.3.1 顺序存储

使用一组地址连续的存储单元存储，例如数组。为了在存储结构中能得到父子结点之间的映射关系，二叉树中的结点必须按层次遍历的顺序存放。具体是：

对于完全二叉树，只需要自根结点起从上往下、从左往右依次存储。
对于非完全二叉树，首先将它变换为完全二叉树，空缺位置用某个特殊字符代替（比如#），然后仍按完全二叉树的存储方式存储。

假设将一棵二叉树按此方式存储到数组后，左子结点下标=2倍的父结点下标+1，右子节点下标=2倍的父结点下标+2（这里父子结点间的关系是基于根结点从0开始计算的）。若数组某个位置处值为#，代表此处对应的结点为空。可以看出顺序存储非常适合存储接近完全二叉树类型的二叉树，对于一般二叉树有很大的空间浪费，所以对于一般二叉树，一般用下面这种链式存储。

2.3.2 链式存储

对每个结点，除数据域外再多增加左右两个指针域，分别指向该结点的左孩子和右孩子结点，再用一个头指针指向根结点。对应的存储结构。
在这里插入图片描述

2.4 遍历

二叉树由三个基本单元组成：根结点，左子树，右子树，因此存在6种遍历顺序，若规定先左后右，则只有以下3种：

2.4.1 先序遍历

若二叉树为空，则空操作；否则：
（1）访问根结点
（2）先序遍历左子树
（3）先序遍历右子树

2.4.2 中序遍历

若二叉树为空，则空操作；否则：
（1）中序遍历左子树
（2）访问根结点
（3）中序遍历右子树

2.4.3 后序遍历

若二叉树为空，则空操作；否则：
（1）后序遍历左子树
（2）后序遍历右子树
（3）访问根结点

下面是将以下二叉树的顺序存储[A,B,C,D,E,F,G,#,#,H,#,#,I]转换为链式存储的代码，结点不存在用字符#表示，并分别遍历。
在这里插入图片描述
对于下面这棵二叉树，其遍历顺序：
先序：ABDEHCFIG
中序：DBHEAFICG
后序：DHEBIFGCA

三：二叉树遍历、查找、删除

3.1 二叉树的遍历

3.1.1 编写节点实体类

/**
 * 创建node节点
 */
class Node {
   

    /**
     * 编号
     */
    private int no;

    /**
     * 姓名
     */
    private String name;

    /**
     * 左节点
     * 默认为null
     */
    private Node left;

    /**
     * 右节点
     * 默认为null
     */
    private Node right;

    /**
     * 含参构造
     *
     * @param no   编号
     * @param name 姓名
     */
    public Node(int no, String name) {
   
        this.no = no;
        this.name = name;
    }

    public int getNo() {
   
        return no;
    }

    public void setNo(int no) {
   
        this.no = no;
    }

    public String getName() {
   
        return name;
    }

    public void setName(String name) {
   
        this.name = name;
    }

    public Node getLeft() {
   
        return left;
    }

    public void setLeft(Node left) {
   
        this.left = left;
    }

    public Node getRight() {
   
        return right;
    }

    public void setRight(Node right) {
   
        this.right = right;
    }

    @Override
    public String toString() {
   
        return "Node{no=" + no + ", name=" + name + "}";
    }

}

3.1.2 前序遍历

/**
     * 前序遍历方法
     */
    public void preOrder() {
   
        //先输出父节点，this指的是当前父节点
        System.out.println(this);
        //向左子树递归前序遍历
        if (this.left != null) {
   
            this.left.preOrder();
        }
        //向右子树递归前序遍历
        if (this.right != null) {
   
            this.right.preOrder();
        }
    }

3.1.3 中序遍历

 /**
     * 中序遍历
     */
    public void infixOrder() {
   
        //递归向左子树中序遍历
        if (this.left != null) {
   
            this.left.infixOrder();
        }
        //输出父节点
        System.out.println(this);
        //向右子树递归中序遍历
        if (this.right != null) {
   
            this.right.infixOrder();
        }
    }

3.1.4 后序遍历

/**
     * 后序遍历
     */
    public void postOrder() {
   
        //递归向左子树后序遍历
        if (this.left != null) {
   
            this.left.postOrder();
        }
        //向右子树递归后序遍历
        if (this.right != null) {
   
            this.right.postOrder();
        }
        //输出父节点
        System.out