二叉树浅析

最新推荐文章于 2024-07-09 21:22:14 发布
最新推荐文章于 2024-07-09 21:22:14 发布
阅读量310 收藏 3
点赞数
分类专栏： Java数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46653783/article/details/112688254
版权

目录

一、什么是二叉树

二叉树是一种特殊的树，那么特殊之处在哪呢：

  • 每个结点最多只能有两个子结点（后文中我用孩子来代替子结点）
    在这里插入图片描述

  • 二叉树是有序树（孩子的前后关系才是我们需要注意的）
    在这里插入图片描述
    这里我们要知道左图中：B是A的左孩子；右图中：C是A的左孩子。

二叉树的所有形态

在这里插入图片描述
上图给出了几种特殊的二叉树形态，从左往右依次是：空树、只有根节点的二叉树、节点只有左子树、节点只有右子树、节点的左右子树均存在，一般二叉树都是由上述基本形态结合而形成的。

二、满二叉树

一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k-1，则它就是满二叉树。
在这里插入图片描述

三、完全二叉树

对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。

注意：满二叉树是一种特殊的完全二叉树。
在这里插入图片描述

四、二叉树的遍历

4.1 树的创建

为了方便后续代码的实现，需要先构建二叉树，本篇博客代码以如图所示二叉树实现。
在这里插入图片描述

public class BuildTree {
    public static TreeNode buildTree1() {
        TreeNode a = new TreeNode('A');
        TreeNode b = new TreeNode('B');
        TreeNode c = new TreeNode('C');
        TreeNode d = new TreeNode('D');
        TreeNode e = new TreeNode('E');
        TreeNode f = new TreeNode('F');
        TreeNode g = new TreeNode('G');
        TreeNode h = new TreeNode('H');
        TreeNode i = new TreeNode('I');
        TreeNode j = new TreeNode('J');
        a.left = b;
        a.right = c;
        b.left = d;
        d.right = g;
        g.left = j;
        c.left = e;
        c.right = f;
        f.left = h;
        f.right = i;
        return a;
    }
}

4.2 深度优先搜索算法DFS

深度优先搜索算法（Depth-First-Search，缩写为 DFS），是一种利用递归实现的搜索算法。

首先我们要明确是怎么遍历二叉树的。二叉树的前中后序遍历，真的真的很好理解，以下图为例：
在这里插入图片描述

从根结点出发的箭头，沿着虚线遍历整个二叉树，最终回到了根节点。我们会发现，在遍历途中，每个结点其实被经过了三次。前序遍历就是第一次碰到结点的顺序（标号1），中序遍历就是第二次碰到结点的顺序（标号2），后序遍历就是第三次碰到结点的顺序（标号3）。这样讲是不是很容易理解。

所以我们明确了前 / 中 / 后序遍历顺序的不同之处：
前序遍历：【根】【左子树】【右子树】
中序遍历：【左子树】【根】【右子树】
后序遍历：【左子树】【右子树】【根】

了解到了这些，对于后文的代码就清晰明了了。

前 / 中 / 后序遍历（递归实现）

public class TreeTraversal {
    /**
     *前序遍历
     */
    public static void preTraversal(TreeNode root) {
        //处理前提
        if(root != null) {
            //处理根节点
            System.out.print(root.value);
            //根据前序的方式，递归处理该结点的左子树
            preTraversal(root.left);
            //根据前序的方式，递归处理该结点的右子树
            preTraversal(root.right);
        }
    }
    
    /**
     *中序遍历
     */
    public static void inTraversal(TreeNode root) {
        if(root != null) {
            inTraversal(root.left);
            System.out.print(root.value);
            inTraversal(root.right);
        }
    }
    
    /**
     *后序遍历
     */
    public static void postTraversal(TreeNode root) {
        if(root != null) {
            postTraversal(root.left);
            postTraversal(root.right);
            System.out.print(root.value);
        }
    }
    
   public static void main(String[] args) {
        TreeNode root = BuildTree.buildTree1();
        System.out.println("前序遍历：");
        preTraversal(root);
        System.out.println();
        System.out.println("中序遍历：");
        inTraversal(root);
        System.out.println();
        System.out.println("后序遍历：");
        postTraversal(root);
    }
}

class TreeNode {
    char value;
    TreeNode left;
    TreeNode right;

    public TreeNode(char value) {
        this.value = value;
    }
}

运行结果：
在这里插入图片描述

前 / 中 / 后序遍历（非递归实现）

/**
     * 前序遍历
     */
    public static void preOrder(TreeNode root) {
        Deque<TreeNode> stacks = new LinkedList<>();
        TreeNode current = root;

        while (!stacks.isEmpty() || current != null) {
            while (current != null) {
                System.out.print(current.value);
                stacks.push(current);
                current  =current.left;
            }
            TreeNode top = stacks.pop();
            current = top.right;
        }
    }

    /**
     * 中序遍历
     */
    public static void inOrder(TreeNode root) {
        Deque<TreeNode> stacks = new LinkedList<>();
        TreeNode current = root;

        while (!stacks.isEmpty() || current != null) {
            while (current != null) {
                stacks.push(current);
                current  =current.left;
            }
            TreeNode top = stacks.pop();
            System.out.print(top.value);
            current = top.right;
        }
    }

    /**
     * 后序遍历
     */
    public static void postOrder(TreeNode root) {
        Deque<TreeNode> stacks = new LinkedList<>();
        TreeNode current = root;
        TreeNode last = null;

        while (!stacks.isEmpty() || current != null) {
            while (current != null) {
                stacks.push(current);
                current  =current.left;
            }
            TreeNode top = stacks.peek();
            if(top.right == null) {
                stacks.pop();
                last = top;
                System.out.print(top.value);
            } else if(top.right == last) {
                stacks.pop();
                last = top;
                System.out.print(top.value);
            } else {
                current = top.right;
            }
        }
    }
    
    public static void main(String[] args) {
        TreeNode root = BuildTree.buildTree1();
        System.out.println("前序遍历：");
        preOrder(root);
        System.out.println();
        System.out.println("中序遍历：");
        inOrder(root);
        System.out.println();
        System.out.println("后序遍历：");
        postOrder(root);
    }
}

运行结果：
在这里插入图片描述

4.3 广度优先搜索算法BFS

广度优先搜索算法（Breadth-First-Search，缩写为 BFS），是一种利用队列实现的搜索算法。

层序遍历

是否是完全二叉树

层序遍历和层号

import java.util.LinkedList;
import java.util.Queue;

public class TreeLevelOrder {
    /**
     * 层序遍历
     */
    public static void levelTraversal(TreeNode root) {
        if(root == null) {
            return;
        }
        //队列的元素类型是树的结点
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.remove();
            //这个node就是我们层序遍历经过的结点
            System.out.print(node.value);

            if(node.left != null) {
                queue.add(node.left);
            }

            if(node.right != null) {
                queue.add(node.right);
            }
        }
    }

    /**
     * 是否是完全二叉树
     */
    public static boolean isCompleteTree(TreeNode root){
        if(root == null || (root.left == null && root.right == null)){
            return true;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode node = null;
        while(!queue.isEmpty()){
            node = queue.peek();
            if(node.left != null){
                queue.add(node.left);
            }else{
                break;
            }
            if(node.right != null){
                queue.add(node.right);
            }else{
                break;
            }
            queue.poll();
        }
        if(queue.peek().right == null){
            queue.poll();
        }
        while(!queue.isEmpty()){
            node = queue.poll();
            if(node.left != null || node.right != null){
                return false;
            }
        }
        return true;
    }

    /**
     * 层序遍历+层数
     */
    public static void levelOrderWithLevel(TreeNode root) {
        if(root == null) {
            return;
        }
        Queue<NL> queue = new LinkedList<>();
        queue.add(new NL(root,1));

        while (!queue.isEmpty()) {
            NL nl = queue.remove();
            TreeNode node = nl.node;
            int level = nl.level;

            System.out.print(level);
            System.out.print(node.value);

            if(node.left != null) {
                queue.add(new NL(node.left,level+1));
            }

            if(node.right != null) {
                queue.add(new NL(node.right,level+1));
            }
        }
    }

    static class NL {
        TreeNode node;
        int level;

        NL(TreeNode node,int level) {
            this.node = node;
            this.level = level;
        }
    }

    public static void main(String[] args) {
        TreeNode root = BuildTree.buildTree1();
        System.out.print("层序遍历：");
        levelTraversal(root);
        System.out.println();
        System.out.print("层序遍历和层号：");
        levelOrderWithLevel(root);
        System.out.println();
        System.out.println("是否是完全二叉树："+isCompleteTree(root));
    }
}

运行结果：
在这里插入图片描述

五、问题求解

二叉树中结点个数

二叉树中叶子结点个数

二叉树第K层的结点个数

二叉树的高度

二叉树中是否包含某个值

二叉树中包含某值所在的节点

结点是不是以root为根的二叉树上的结点

public class SomeMethod {
    private static int n = 0;

    /**
     * 返回root为根的树中，有多少个结点
     */
    private static void preOrder(TreeNode root) {
        //1.一个树的结点 2.没有结点
        if(root != null) {
            n++;
            preOrder(root.left);
            preOrder(root.right);
        }
    }

    public static int sumTreeNodeSize(TreeNode root) {
        preOrder(root);
        return n;
    }

    public static int sumTreeNodeSize2(TreeNode root) {
        if(root != null) {
            int rootNodeSize = 1;
            int leftSubTreeNodeSize = sumTreeNodeSize2(root.left);
            int rightSubTreeNodeSize = sumTreeNodeSize2(root.right);
            return rightSubTreeNodeSize+leftSubTreeNodeSize+rootNodeSize;
        }
        return 0;
    }

    /**
     * 求叶子结点个数
     */
    private static int m = 0;

    private static void preOrder2(TreeNode root) {
        if(root != null) {
            if(root.left == null && root.right == null) {
                m++;
            }
            preOrder2(root.left);
            preOrder2(root.right);
        }
    }

    public static int sumTreeLeafNodeSize(TreeNode root) {
        m = 0;//保证下次打印
        preOrder2(root);
        return m;
    }

    public static int sumTreeLeafNodeSize2(TreeNode root) {
        if(root == null) {
            return 0;
        } else if(root.left == null && root.right == null) {
            return 1;
        } else {
            int leftSubTreeNodeSize = sumTreeLeafNodeSize2(root.left);
            int rightSubTreeNodeSize = sumTreeLeafNodeSize2(root.right);
            return rightSubTreeNodeSize + leftSubTreeNodeSize;
        }
    }

    /**
     *求二叉树第K层的结点个数
     */
    public static int sumKLevelNodeSize(TreeNode root,int k) {
        if(root == null) {
            return 0;
        } else if(k == 1) {
            return 1;
        } else {
            int leftSubTreeK_1 = sumKLevelNodeSize(root.left,k-1);
            int rightSubTreeK_1 = sumKLevelNodeSize(root.right,k-1);
            return leftSubTreeK_1 + rightSubTreeK_1;
        }
    }

    /**
     * 求二叉树的高度
     */
    public static int getHeight(TreeNode root) {
        if(root == null) {
            return 0;
        } else if(root.left == null && root.right == null) {//可以和下面else合并
            return 1;
        } else {
            int leftTreeHeight = getHeight(root.left);
            int rightTreeHeight = getHeight(root.right);
            return Math.max(leftTreeHeight,rightTreeHeight)+1;
        }

    }

    /**
     * 二叉树中是否包含某个数
     */
    public static boolean containsTree(TreeNode root,char v) {
        if(root == null) {
            return false;
        } else {
            if(root.value == v) {
                return true;
            } else {
                boolean leftSubTreeContains = containsTree(root.left, v);
                if(leftSubTreeContains) {
                    return true;
                } else {
                    boolean rightSubTreeContains = containsTree(root.right,v);
                    if(rightSubTreeContains) {
                        return true;
                    } else {
                        return false;
                    }
                }
            }
        }
    }

    public static boolean containsTree2(TreeNode root,char v) {
        if(root == null) {
            return false;
        }

        if(root.value == v) {
            return true;
        }

        boolean left = containsTree2(root.left,v);
        if(left) {
            return true;
        }
        return containsTree2(root.right,v);
    }

    /**
     * 返回包含v所在的节点
     */
    public static TreeNode containsTree3(TreeNode root,char v) {
        if(root == null) {
            return null;
        }

        if(root.value == v) {
            return root;
        }

        TreeNode leftContains = containsTree3(root.left, v);
        if(leftContains != null) {
            return leftContains;
        }
        return containsTree3(root.right,v);
    }

    /**
     * 返回node是不是以root为根的二叉树上的一个结点
     * 空树一律返回false，即使找的是null
     */
    public static boolean containsTree4(TreeNode root,TreeNode node) {
        if(root == null) {
            return false;
        }
        if(root == node) {
            return true;
        }
        boolean leftVontains = containsTree4(root.left, node);
        if(leftVontains) {
            return true;
        }

        return containsTree4(root.right,node);
    }

    public static void main(String[] args) {
        TreeNode root = BuildTree.buildTree1();
        System.out.println("二叉树的结点个数："+sumTreeNodeSize(root));//10
        System.out.println("二叉树的结点个数："+sumTreeNodeSize2(root));//10
        System.out.println("二叉树的叶子结点个数："+sumTreeLeafNodeSize(root));//4
//        System.out.println("二叉树的叶子结点个数："+sumTreeLeafNodeSize(root));//8
        System.out.println("二叉树的叶子结点个数："+sumTreeLeafNodeSize2(root));//4
        System.out.println("二叉树的第一层有："+sumKLevelNodeSize(root, 1)+"个结点");
        System.out.println("二叉树的第四层有："+sumKLevelNodeSize(root, 4)+"个结点");
        System.out.println("二叉树的高度："+getHeight(root));
        System.out.println("二叉树中是否包含F:"+containsTree(root,'F'));
        System.out.println("二叉树中是否包含F:"+containsTree2(root,'F'));
        System.out.println("二叉树中包含F的结点:"+containsTree3(root, 'F').value);
        System.out.println("结点是否是以root为根的二叉树上的节点："+containsTree4(root, root));
    }
}

运行结果：
在这里插入图片描述

浪漫不死
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python数据结构之栈、队列及二叉树定义与用法浅析
09-19
### Python数据结构之栈、队列及二叉树定义与用法浅析 #### 栈 **栈**是一种特殊的线性表，它只能允许在一端进行插入和删除操作，这一端被称为栈顶(top)，另一端被称为栈底(bottom)。遵循先进后出（First In Last ...
使用Python操作二叉树的插入查询遍历和打印
王佳宇的个人博客
11-07 7369
在了解二叉树之前呢我们需要说明一下为什么会有这种树的结构，也就是二叉树的优点！ 既然说到数据结构那无非就是用来存储数据、修改数据、查找数据、使本来没有意义的字符、数字等变的有意义。 说到存储数据、修改数据、查找数据，数组就是一个我们最新接触到的结构，在到后来内部由数组作为基础所进化而来的泛型集合、非泛型集合、栈、队列、抛开队列和栈这种自由度低的结构不讲。 我们来说一说泛型集合,一个有序的Li...
二叉树前序遍历python输出_python先序遍历二叉树问题
weixin_39955149的博客
12-13 334
问题如何遍历一个二叉树遍历二叉树就是访问二叉树的每一个节点二叉树父结点下先左访问，先序遍历(根左右)例如：遍历以下的二叉树遍历结果：ABDECFPython代码示例# !/usr/bin/env python# -*-encoding: utf-8-*-# author:LiYanwei# version:0.1class TreeNode(object):'''二叉树类'''def __init...
二叉树超详细解析
最新发布
qq_63730529的博客
07-09 1060
二叉树的创建，遍历方法，前序遍历，中序遍历，后序遍历的方法
python实现平衡二叉树的基本操作(创建、遍历、打印)
YTIANYE的博客
07-25 972
目录 平衡二叉树的主要操作 AVL.py tree.py github: 平衡二叉树的主要操作 """FUN0 初始化""" """FUN1 由无序数组创建平衡二叉树 """ """FUN2 向平衡二叉树添加节点 """ """FUN3 将二叉树恢复平衡""" """FUN4 计算每个结点的height""" """FUN5 计算每个结点的balance""" """FUN6 左旋""" """FUN7 右旋""" """
Python 数据结构之二叉树的实现
haeasringnar的博客
02-09 867
1、基本概念 二叉树 是一种简单的树形结构，是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树是一种递归结构。 二叉树的基本概念 空树：不包含任何节点的二叉树成为空树。只包含一个节点的二叉树称为一个单点树。 父节点和子节点：一颗二叉树的根节点称为该数的子树根节点的父节点，与之对应的，子数的根节点称为二叉树树根节...
数据结构学习笔记（六）：二叉树（Binary Tree）
文程序公子的博客
06-13 1994
1 树与二叉树的概念 1.1 树的概念 前面笔记中介绍的链表、栈、队列、数组和字符串组织数据的方式都是
平衡二叉树（AVL树）浅析
10-20
文档"平衡二叉树（AVL树）浅析.doc"应该包含了详细的理论解释和可能的示例图，有助于理解和学习AVL树的原理。 总的来说，AVL树通过维持树的平衡状态，确保了高效的查找、插入和删除操作。学习和掌握AVL树的原理和...
浅析数据结构中二叉树的生成.pdf
08-07
二叉树是数据结构领域中一个非常重要的概念，它是计算机科学的基础之一。本文介绍了二叉树的基本原理，并通过实际例子演示了如何生成二叉树，并通过不同类型的遍历序列输出二叉树中的结点数据。 首先，二叉树是由一...
浅析递归
03-24
1. **数据结构**：在处理树形结构（如二叉树）或图结构时，递归非常有用，例如遍历、搜索和排序。 2. **数学问题**：许多数学问题，如阶乘计算、斐波那契数列等，都可以用递归来解决。 3. **分治算法**：分治策略...
基于Python的数据结构实验——二叉树的构建与遍历（先序、中序、后序、层次遍历，修改、添加节点）（附详细代码和注释）
为人民服务
01-13 2478
（注：我使用的二叉树写入的方法是，一层一层写，有两个规矩，一是确保每一个节点的孩子都必须是写入了数据的节点或#节点，二是确保最后一个#之前不能存在空节点，即对于上述二叉树，其应该表示为ABCDEFGH##IJ#############，分层后是A|BC|DEFG|H##IJ###|##########）创建名为 prac07.py 的文件，在文件中定义两个类，一个是二叉树的结点类，该类 包含结点的相关信息(如结点的值和左、右子树);另一个是二叉树的类，该类包含二叉树的定 义及其基本操作。
会发光的二叉树（背景+自动闪烁+自动刷新）
05-07
开发工具是VC 6.0。生成二叉树节点信息的核心算法来源于：http://topic.csdn.net/u/20120411/12/792b7b0c-fb57-4e5c-9cab-0a1595679d40.html 在此程序基础上增加了背景色、自动闪烁、自动更新等特性，绘图接口包括GDI以及GDI+，其中GDI+黑色背景的自动闪烁效果较GDI更佳。 应用程序采用和原作完全不同的结构设计方式，利用Controller分离了模型和视图（MVC），并通过接口ITree、IPaint、ITreeModel降低模块间的耦合度，提高了二叉树模型部分的可复用性（白盒复用）。 注意：程序正常编译需要Gdiplus的支持。
二叉树前序遍历python输出_二叉树的前序遍历、中序遍历、后序遍历、python递归和非递归实现,及...
weixin_39590601的博客
12-10 221
这块一直有点迷，梳理梳理。1. 中序遍历1.1 递归实现每次递归，只需要判断节点是不是None，否则按照左中右的顺序打印出节点value值。class Solution:def inorderTraversal(self, root):if not root:return Nonereturn self.inorderTraversal(root.left) + [root.val] + self...
python二叉树的建立与遍历完整代码_如何使用Python语言实现二叉树结构与进行二叉树遍历...
weixin_39713538的博客
12-17 584
本文主要向大家介绍了Python语言如何实现二叉树结构与进行二叉树遍历，通过具体的代码向大家展示，希望对大家学习Python语言有所帮助。classBinaryTree:def__init__(self,root):self.key=rootself.left_child=Noneself.right_child=Nonedefinsert_left(self,new_nod...
二叉树前序遍历python输出_Python实现输入二叉树的先序和中序遍历，再输出后序遍历操作示...
weixin_39848007的博客
12-10 482
本文实例讲述了Python实现输入二叉树的先序和中序遍历，再输出后序遍历操作。，具体如下：实现一个功能：输入:一颗二叉树的先序和中序遍历输出:后续遍历思想：先序遍历中，第一个元素是树根在中序遍历中找到树根，左边的是左子树 右边的是右子树Python代码：# -*- coding:utf-8 -*-def fromFMtoL( mid ):global las #全局后序遍历global fir #...
二叉树及其作用浅析
热门推荐
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
10-14 1万+
在学习数据结构和算法时看到各种树，把人都整蒙了，枯燥且提不起学习兴趣。等逐渐感受到二叉树的神奇作用和巨大的应用价值后，觉得二叉树原来也这么有趣，值得好好学习。 先从整体上认识下二叉树及其他各种树的区别和用途。 大致有哪些树？ 树有很多种，其中二拆树因为其特殊的结构和特点在计算上最为常用。 常见的二叉树：二叉查找树，平衡二叉树(AVL)，红黑树，B+树，B-树，字典树，满二叉树，完全二叉树，霍夫曼树，伸展树，最小堆，最大堆等。 二叉树有什么用？ 二叉树应用非常广泛。 在操作系统源程序中，树和.
python实现二叉树的创建、前序遍历、中序遍历以及层次遍历
qq_42025868的博客
02-25 6093
二叉树的概念 二叉树是指度不超过2的树，可以由n个结点构成，如下图。 二叉树的创建 注意：输入的格式，如下图，D结点的孩子结点，空结点用#代替，直到最后一层就可以停止输入，以下面这棵树为例，则我们的输入为 ABCDE#F##G##### class CreateBiTree: """ str_tree: 传入字符串 return: 返回根结点 """ def __init__(self, str_tree): self.str_tree = s
Python实现二叉树的前中后序遍历
星宇的博客
05-22 4373
Python实现二叉树的前中后序遍历
二叉树的叶子节点（二叉树）
持续学习，刻意练习
11-02 4880
1.题目：  Problem Description 给你一串扩展二叉树的前序遍历序列，按输入的先后顺序输出该二叉树的叶子节点。  Input 输入的第一行有一个整数N,表示接下去有N组测试数据，每组测试数据占一行，每组测试数据为一串扩展二叉树的前序遍历序列，节点数据类型为字符型，其中'#'标识该节点为空。  Output
二叉树操作算法详解
"二叉树相关的C语言实现代码，包括初始化、创建、遍历等基本操作" 二叉树是一种在计算机科学中广泛使用的数据结构，它由节点（或称为结点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值