数据结构与算法--二叉树入门(链式存储)

树的定义

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

树具有以下特点

  1. 每个结点有零个或多个子结点，比如：B结点有一个D字节点，G结点没有子节点

  2. 没有父结点的结点为根结点，比如：A结点

  3. 每一个非根结点只有一个父结点，比如：C结点只有A结点为父节点

  4. 每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树，比如：结点D、G、H、I 为B的一颗子树

树的相关术语

结点的度： 一个结点含有的子树的个数称为该结点的度

叶结点： 度为0的结点称为叶结点，也可以叫做终端结点，比如：G,H,I,J,F

分支结点： 度不为0的结点称为分支结点，也可以叫做非终端结点，比如：B,C,D,E

结点的层次： 从根结点开始，根结点的层次为1，根结点的直接后继层次为2，以此类推

结点的层序编号： 将树中的结点，按照从上层到下层，同层从左到右的次序排成一个线性序列，把他们编成连续的自然数

树的度： 树中所有结点的度的最大值，比如：D结点的度为3，所以此棵树的度为3

树的高度(深度)：树中结点的最大层次，比如：此棵树的深度为4

森林： m（m>=0）个互不相交的树的集合，将一颗非空树的根结点删去，树就变成一个森林；给森林增加一个统一的根结点，森林就变成一棵树

孩子结点： 一个结点的直接后继结点称为该结点的孩子结点，比如：B结点的孩子结点为D，D结点的孩子结点为G、H、I

双亲结点(父结点)：一个结点的直接前驱结点称为该结点的双亲结点，比如：D结点的双亲结点为B

兄弟结点： 同一双亲结点的孩子结点间互称兄弟结点，比如：结点G、H、I为兄弟结点

二叉树的基本定义

二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成

二叉树有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空

二叉树就是度不超过2的树(每个结点最多有两个子结点)

二叉树的特点

  1. 每个结点最多有两颗子树，所以二叉树中不存在度大于2的结点

  2. 左子树和右子树是有顺序的，次序不能任意颠倒

  3. 即使树中某结点只有一棵子树，也要区分它是左子树还是右子树

二叉树的性质

  1. 在二叉树的第i层上最多有 2(i-1)个节点 。（i>=1）

  2. 二叉树中如果深度为k,那么最多有 2k - 1 个节点。(k>=1）

  3. n0=n2+1 , n0表示度数为0的节点数，n2表示度数为2的节点数。即度为0的节点数=度为2的节点数+1

  4. 在完全二叉树中，具有n个节点的完全二叉树的深度为log2n+1，其中log2n是向下取整

  5. 若对含 n 个结点的完全二叉树从上到下且从左至右进行 1 至 n 的编号，则对完全二叉树中任意一个编号为 i 的结点有如下特性

(1) 若 i=1，则该结点是二叉树的根，无双亲, 否则编号为 [i/2] 的结点为其双亲结点

(2) 若 2i>n，则结点i为叶子结点，该结点无左孩子， 否则编号为 2i 的结点为其左孩子结点

(3) 若 2i+1>n，则该结点无右孩子结点， 否则编号为2i+1 的结点为其右孩子结点

满二叉树

满二叉树：一个二叉树，如果每一个层的结点树都达到最大值，则这个二叉树就是满二叉树

满二叉树的特点

  1. 叶子只能出现在最下一层。出现在其它层就不可能达成平衡

  2. 非叶子结点的度一定是2

  3. 在同样深度的二叉树中，满二叉树的结点个数最多，叶子数最多

完全二叉树

完全二叉树：对一颗具有n个结点的二叉树按层编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这棵二叉树称为完全二叉树

完全二叉树： 叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树

完全二叉树的特点

  1. 叶子结点只能出现在最下层和次下层

  2. 最下层的叶子结点集中在树的左部

  3. 倒数第二层若存在叶子结点，一定在右部连续位置

  4. 如果结点度为1，则该结点只有左孩子，即没有右子树

  5. 同样结点数目的二叉树，完全二叉树深度最小

    注：满二叉树一定是完全二叉树，但反过来不一定成立

二叉查找树的创建

二叉树设计

二叉树的存储结构有两种，分别为顺序存储和链式存储

采用顺序存储。指的是使用顺序表（数组）存储二叉树。需要注意的是，顺序存储只适用于完全二叉树

image-20220810202815916

  • 顺序存储的完全二叉树的特征（n表示二叉树中第几个元素，按0开始编号）

    • 第n个元素的左子节点为2n+1

    • 第n个元素的右子节点为2n+2

    • 第n个元素的父节点为(n-1)/2

  • 如果想顺序存储普通二叉树，需要提前将普通二叉树转化为完全二叉树

    • 普通二叉树转完全二叉树的方法很简单，只需给二叉树额外添加一些节点，将其"拼凑"成完全二叉树即可

      image-20220810201905950

根据对图的观察，发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，设计一个结点类来描述结点这个事物。

采用链式存储。由二叉树定义可知，二叉树的每个结点最多有两个孩子。因此，可以将结点数据结构定义为一个数据和两个指针域。

public class Node<Key,Value> {

    /**存储值*/
    public Value value;
    
    /**存储键*/
    public Key key;
    
    /**记录左子节点*/
    public Node left;
    
    /**记录右子节点*/
    public Node right;

    public Node(Key key, Value value, Node left, Node right) {
        this.value = value;
        this.key = key;
        this.left = left;
        this.right = right;
    }
}

二叉查找树实现

插入方法put实现思想

  1. 如果当前树中没有任何一个结点，则直接把新结点当做根结点使用

  2. 如果当前树不为空，则从根结点开始：

    1. 如果新结点的key小于当前结点的key，则继续找当前结点的左子结点

    2. 如果新结点的key大于当前结点的key，则继续找当前结点的右子结点

    3. 如果新结点的key等于当前结点的key，则树中已经存在这样的结点，替换该结点的value值即可

查询方法get实现思想

从根节点开始：

  1. 如果要查询的key小于当前结点的key，则继续找当前结点的左子结点

  2. 如果要查询的key大于当前结点的key，则继续找当前结点的右子结点

  3. 如果要查询的key等于当前结点的key，则树中返回当前结点的value

删除方法delete实现思想

  1. 找到被删除结点

  2. 找到被删除结点右子树中的最小结点minNode

  3. 删除右子树中的最小结点

  4. 让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子树

  5. 让被删除结点的父节点指向最小结点minNode

public class BinaryTree<Key extends Comparable<Key>,Value> {

    /**记录根节点*/
    private Node root;
    
    /**记录树中结点的个数*/
    private int N;

    public BinaryTree() {
    }

    /**向树中插入一个键值对*/
    public void put(Key key,Value value){

        root = put(root, key, value);
    }

    /**给指定树x上，添加一个键值对，并返回添加后的新树*/
    private Node put(Node x,Key key,Value value){

        //1.如果x子树为空
        if (x == null) {
            N++;
            return new Node(key,value,null,null);
        }

        //2.如果x子树不为空，比较x的键和key的大小
        int compare = key.compareTo((Key) x.key);

        if (compare < 0){
            //2.1如果key小于x结点的键，则继续找x结点的左子树
            x.left = put(x.left,key,value);

        }else if (compare > 0){
            //2.2如果key大于x结点的键，则继续找x结点的右子树
            x.right = put(x.right,key,value);

        }else{
            //2.3如果key等于x结点的键，则替换x结点的值
            x.value = value;
        }

        return x;
    }

    /**根据key，从树中找出对应的值*/
    public Value get(Key key){

        return get(root,key);
    }

    /**从指定的树x中，找出key对应的值*/
    private Value get(Node x,Key key){

        //1.如果x树为空
        if (x == null) {
            return null;
        }

        //2.如果x子树不为空，比较x的键和key的大小
        int compare = key.compareTo((Key) x.key);

        if (compare < 0){
            //2.1如果key小于x结点的键，则继续找x结点的左子树
            return get(x.left,key);


        }else if (compare > 0){
            //2.2如果key大于x结点的键，则继续找x结点的右子树
            return get(x.right,key);

        }else{
            //2.3如果key等于x结点的键，则返回x结点的值
            return (Value) x.value;
        }
    }

    /**根据key，删除树中对应的键值对*/
    public void delete(Key key){

        root = delete(root,key);
    }

    /**删除指定树x上的键为key的键值对，并返回删除后的新树*/
    private Node delete(Node x,Key key){

        //1.如果x树为空
        if (x == null) {
            return null;
        }

        //2.如果x子树不为空，比较x的键和key的大小
        int compare = key.compareTo((Key) x.key);

        if (compare < 0){
            //2.1如果key小于x结点的键，则继续找x结点的左子树
            x.left = delete(x.left,key);

        }else if (compare > 0){
            //2.2如果key大于x结点的键，则继续找x结点的右子树
            x.right = delete(x.right,key);

        }else{

            //元素个数减1
            N--;

            //2.3如果key等于x结点的键，完成真正的删除操作，要删除的结点就是x

            //2.3.1得到右子树中最小的结点
            //1.如果当前结点的右子树不存在，则直接返回当前结点的左子结点
            if (x.right == null) {
                return x.left;
            }

            //2.如果当前结点的左子树不存在，则直接返回当前结点的右子结点
            if (x.left == null) {
                return x.right;
            }

            //3.当前结点的左右子树都存在
            // 3.1找到右子树中最小的结点
            Node minNode = x.right;
            while (minNode.left != null) {
                minNode = minNode.left;
            }

            //3.2删除右子树中最小的结点
            Node n = x.right;
            while (n.left != null) {
                if (n.left.left == null) {
                    n.left = null;
                }else {
                    //变换n结点
                    n = n.left;
                }
            }

            //让被删除结点的左子树称为最小结点minNode的左子树
            minNode.left = x.left;

            //让被删除结点的右子树称为最小结点 minNode的右子树
            minNode.right = x.right;

            //让被删除结点的父节点指向最小结点minNode
            x = minNode;
        }
        return x;
    }

    /**获取树中元素的个数*/
    public int size(){
        return N;
    }
}

 查找二叉树中最小的键

 在某些情况下，需要查找出树中存储所有元素的键的最小值，比如树中存储的是学生的排名和姓名数据，那么需要查找出排名最低是多少名？这里设计如下两个方法来完成

/**找出树中最小的键*/
public Key min(){

    return (Key) min(root).key;
}

/**找出最小的键在树x中的结点*/
private Node min(Node x){
    //如果x存在左点，则继续寻找最小键所在结点，如果没有则直接返回最小键所在的结点
    if (x.left != null) {
        return min(x.left);
    }else{
        return x;
    }
}

 查找二叉树中最大的键

 在某些情况下，需要查找出树中存储所有元素的键的最大值，比如树中存储的是学生的成绩和学生的姓名，那么需要查找出最高的分数是多少？这里设计两个方法来完成

/**找出树中最大的键*/
public Key max(){

    return (Key) max(root).key;
}

/**找出最大的键在树x中的结点*/
private Node max(Node x){
    //如果x存在右节点，则继续寻找最大键所在结点，如果没有则直接返回最大键所在的结点
    if (x.right != null) {
        return max(x.right);
    }else{
        return x;
    }
}

二叉树的基础遍历

很多情况下，可能需要像遍历数组数组一样，遍历树，从而拿出树中存储的每一个元素，由于树状结构和线性结构不一样，它没有办法从头开始依次向后遍历，所以存在如何遍历，也就是按照什么样的搜索路径进行遍历的问题

把树简单的画作上图中的样子，由一个根节点、一个左子树、一个右子树组成，那么按照根节点什么时候被访问，可以把二叉树的遍历分为以下三种方式：

  1. 前序遍历

    先访问根结点，然后再访问左子树，最后访问右子树

  2. 中序遍历

    先访问左子树，中间访问根节点，最后访问右子树

  3. 后序遍历

    先访问左子树，再访问右子树，最后访问根节点

如果分别对下面的树使用三种遍历方式进行遍历，得到的结果如下：

前序遍历

实现步骤

  1. 把当前结点的key放入到队列中

  2. 找到当前结点的左子树，如果不为空，递归遍历左子树

  3. 找到当前结点的右子树，如果不为空，递归遍历右子树

/**使用前序遍历，获取整个树中的所有键*/
public Queue<Key> preErgodic(){

    Queue<Key> keys = new LinkedList<>();

    preErgodic(root,keys);

    return keys;
}

/**使用前序遍历，把指定树x中的所有键放入到keys队列中*/
private void preErgodic(Node x,Queue<Key> keys){

    if (x == null) {
        return;
    }

    //1.把当前结点的key放入到队列中
    keys.add((Key) x.key);

    //2.找到当前结点的左子树，如果不为空，递归遍历左子树
    if (x.left != null) {
        preErgodic(x.left,keys);
    }

    //3.找到当前结点的右子树，如果不为空，递归遍历右子树
    if (x.right != null) {
        preErgodic(x.right,keys);
    }
}

中序遍历

实现步骤

  1. 找到当前结点的左子树，如果不为空，递归遍历左子树

  2. 把当前结点的key放入到队列中

  3. 找到当前结点的右子树，如果不为空，递归遍历右子树

/**使用中序遍历，获取整个树中的所有键*/
public Queue<Key> midErgodic(){

    Queue<Key> keys = new LinkedList<>();
    midErgodic(root,keys);
    return keys;
}

/**使用中序遍历，把指定树x中的所有键放入到keys队列中*/
private void midErgodic(Node x, Queue<Key> keys) {

    if (x == null) {
        return;
    }

    //1.找到当前结点的左子树，如果不为空，递归遍历左子树
    if (x.left != null) {
        midErgodic(x.left,keys);
    }

    //2.把当前结点的key放入到队列中
    keys.add((Key) x.key);

    //3.找到当前结点的右子树，如果不为空，递归遍历右子树
    if (x.right != null) {
        midErgodic(x.right,keys);
    }
}

后序遍历

实现步骤

  1. 找到当前结点的左子树，如果不为空，递归遍历左子树

  2. 找到当前结点的右子树，如果不为空，递归遍历右子树

  3. 把当前结点的key放入到队列中

/**使用后序遍历，获取整个树中的所有键*/
public Queue<Key> afterErgodic(){

    Queue<Key> keys = new LinkedList<>();

    afterErgodic(root,keys);

    return keys;
}

/**使用后序遍历，把指定树x中的所有键放入到keys队列中*/
private void afterErgodic(Node x, Queue<Key> keys) {

    if (x == null) {
        return;
    }

    //1.找到当前结点的左子树，如果不为空，递归遍历左子树
    if (x.left != null) {
        afterErgodic(x.left,keys);
    }

    //2.找到当前结点的右子树，如果不为空，递归遍历右子树
    if (x.right != null) {
        afterErgodic(x.right,keys);
    }

    //3.把当前结点的key放入到队列中
    keys.add((Key) x.key);
}

二叉树的层序遍历

所谓的层序遍历，就是从根节点（第一层）开始，依次向下，获取每一层所有结点的值

那么层序遍历的结果是：EBGADFHC

实现步骤

  1. 创建队列，存储每一层的结点

  2. 使用循环从队列中弹出一个结点

    2.1获取当前结点的key

    2.2如果当前结点的左子结点不为空，则把左子结点放入到队列中

    2.3如果当前结点的右子结点不为空，则把右子结点放入到队列中

/**使用层序遍历，获取整个树中的所有键*/
public Queue<Key> layerErgodic(){

    //存储键的队列
    Queue<Key> keys = new LinkedList<>();

    //存储键所在的结点
    Queue<Node> nodes = new LinkedList<>();

    //先把根节点放在nodes中
    nodes.add(root);

    Node n = null;

    while (!nodes.isEmpty()) {

        //从队列中弹出一个节点，将该结点的键放到keys中
        n = nodes.poll();
        keys.add((Key) n.key);

        //判断当前结点是否还有左孩子结点，如果有，将其加入nodes队列中
        if (n.left != null) {
            nodes.add(n.left);
        }

        //判断当前结点是否还有右孩子结点，如果有，将其加入nodes队列中
        if (n.right != null) {
            nodes.add(n.right);
        }
    }
    return keys;
}

二叉树应用问题

二叉树的最大深度问题

需求：给定一棵树，请计算树的最大深度（树的根节点到最远叶子结点的最长路径上的结点数）

上面这棵树的最大深度为4

实现步骤

  1. 如果根结点为空，则最大深度为0

  2. 计算左子树的最大深度

  3. 计算右子树的最大深度

  4. 当前树的最大深度=左子树的最大深度和右子树的最大深度中的较大者+1

/**计算整个树的最大深度*/
public int maxDepth(){

    return maxDepth(root);
}

/**计算指定树x的最大深度*/
private int maxDepth(Node x){

    //1.如果根结点为空，则最大深度为0
    if (x == null) {
        return 0;
    }
	//x的最大深度
    int max = 0;
    //左子树的最大深度
    int maxL = 0;
    //右子树的最大深度
    int maxR = 0;

    //2.计算x结点左子树的最大深度
    if (x.left != null) {
        maxL = maxDepth(x.left);
    }

    //3.计算x结点右子树的最大深度
    if (x.right != null) {
        maxR = maxDepth(x.right);
    }

    //4.当前树的最大深度=左子树的最大深度和右子树的最大深度中的较大者+1
    max = maxL > maxR ? maxL + 1 : maxR + 1;
    return max;
}
posted @   伊文小哥  阅读(522)  评论(0)  编辑  收藏  举报
相关博文：
· 数据结构与算法--线索化二叉树
· 数据结构与算法--顺序存储二叉树
· 数据结构与算法
· 【数据结构与算法】树专题
· 二叉树的简单认识
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
点击右上角即可分享
微信分享提示
AI IDE Trae