实现二叉树的基本操作与OJ练习

最新推荐文章于 2024-05-20 22:31:31 发布
最新推荐文章于 2024-05-20 22:31:31 发布
阅读量772 收藏 22
点赞数 29
分类专栏： 数据结构(Java) 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65465009/article/details/135306180
版权

目录

1.二叉树的基本操作

1.1二叉树基本操作完整代码 

 1.2检测value值是否存在

1.3层序遍历

1.4判断一棵树是不是完全二叉树 

 2.OJ练习

2.1平衡二叉树

2.2对称二叉树 

2.3二叉树遍历 

1.二叉树的基本操作

1.1二叉树基本操作完整代码 

public class BinaryTree {
    static class TreeNode{
        public char val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(char val) {
            this.val = val;
        }
    }
    //使用穷举，实现一棵树
    public TreeNode creatTree() {
        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');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        E.right = H;
        return A;
    }
    // 前序遍历  根 左子树 右子树
     public void preOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }
    // 中序遍历 左 根 右
    public void inOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }
    // 后序遍历 左 右 根
    public void postOrder(TreeNode root){
        if (root == null) {
            return;
        }
        inOrder(root.left);
        inOrder(root.right);
        System.out.print(root.val + " ");
    }
    // 获取树中节点的个数
    public int sizeCount;
    public void size(TreeNode root){
        if(root == null) {
            return;
        }
        sizeCount++;
        size(root.left);
        size((root.right));
    }
    //子问题
    public int  size2(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return size2(root.left) + size2(root.right) + 1;
    }
    // 获取叶子节点的个数
    public int leafCount;
    //遍历求解
    public void getLeafNodeCount(TreeNode root) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null){
            leafCount++;
        }
        getLeafNodeCount(root.left);
        getLeafNodeCount(root.right);
    }
    // 子问题思路-求叶子结点个数
    public 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层节点的个数
    public 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);
    }
    // 获取二叉树的高度
    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        return Math.max(leftHeight,rightHeight) + 1;
    }
    // 检测值为value的元素是否存在
    public TreeNode find(TreeNode root, int val) {
        if (root == null) {
            return null;
        }
        if (root.val == val) {
            return root;
        }
        TreeNode leftVal = find(root.left,val);
        if (leftVal != null) {
            return leftVal;
        }
        TreeNode rightVal =find(root.right,val);
        if (rightVal != null) {
            return rightVal;
        }
        //左、右子树都没有
        return null;
    }
    //层序遍历
    public 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);
            }
        }
    }
    //判断一棵树是不是完全二叉树
   public boolean isCompleteTree(TreeNode root){
        if(root == null) {
            return true;
        }
       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;
           }
       }
       //走到这里两种情况 1.队列为空 2.遇到break
       while (!queue.isEmpty()) {
           TreeNode cur = queue.peek();
           if (cur != null) {
               queue.poll();
           } else {
               return false;
           }
       }
        return true;
   }
}

 1.2检测value值是否存在

题解：

1.3层序遍历

题解：

层序遍历：就是从上到下，从左到右，依次遍历。前序、中序、后序本质上都是从上到下。

所以，就是要解决从左到右。

可以引入队列解决(先进先出)，如果不是空树，先把根节点放到队列里，此时队列不为空，当该节点出队是，用cur记录，不为空并把该节点的左、右节点放进队列。

1.4判断一棵树是不是完全二叉树 

题解：

也是引入队列解决，当cur不为空把该节点的左、右节点放进队列；否则跳出循环。

在遍历队列，是否都为null.

 2.OJ练习

2.1平衡二叉树

题解：

是不是一颗平衡二叉树，当前根节点的左右子树的高度差的绝对值<=1&&根左子树平衡&&根右子树平衡。

如下代码：就会发现求节点3的高度，把每个节点都求了一遍。 求节点9的高度时，也把每个节点都求了一遍。就会有很高度重复求，maxDepth有N个节点，最坏时间复杂度:N*N=N^2.

    public boolean isBalanced(TreeNode root) {
        if(root == null) {
            return true;
        }
        int leftHeight = maxDepth(root.left);
        int rightHeight = maxDepth(root.right);
        return Math.abs(leftHeight - rightHeight) <= 1 &&
                isBalanced(root.left)&&isBalanced(root.right);

    }
   public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = maxDepth(root.left);
        int rightHeight = maxDepth(root.right);
        return Math.max(leftHeight, rightHeight) + 1;
    }

 省略掉重复计算的高度！

    public boolean isBalanced2(TreeNode root) {
        if(root == null) {
            return true;
        }

        return maxDepth(root) >= 0;

    }
    public int maxDepth2(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = maxDepth2(root.left);
        if(leftHeight < 0) {
            return -1;
        }
        int rightHeight = maxDepth2(root.right);
        if(leftHeight >= 0 && rightHeight >= 0
                && Math.abs(leftHeight - rightHeight) <= 1){
            return Math.max(leftHeight,rightHeight) + 1;
        } else {
            return -1;
        }
    }

2.2对称二叉树 

     题目描述：给你一个二叉树的根节点 root ， 检查它是否轴对称。 

题解：

    public boolean isSymmetric(TreeNode root) {
        if(root == null) {
            return true;
        }
        return isSameTree2(root.left,root.right);

    }
    public boolean isSameTree2(TreeNode lefTree,TreeNode rightTree){
        if(lefTree == null && rightTree != null || lefTree != null && rightTree == null) {
            return false;
        }
        if(lefTree == null && rightTree == null) {
            return true;
        }
        if(lefTree.val != rightTree.val) {
            return false;
        }
        return isSameTree2(lefTree.left,rightTree.right)
                &&isSameTree2(lefTree.right,rightTree.left);
    }

2.3二叉树遍历 

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

题解： 

  遍历这个字符串，根据前序遍历的方式，创建二叉树

   class TreeNode {
        char val;
        TreeNode left;
        TreeNode right;

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

    // 注意类名必须为 Main, 不要有任何 package xxx 信息
    public class Main {
        public static int i = 0;
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            // 注意 hasNext 和 hasNextLine 的区别
            while (in.hasNextLine()) { // 注意 while 处理多个 case
                String str = in.nextLine();

                TreeNode root = creatTree(str);

                inOrder(root);
            }
        }
        public static TreeNode creatTree(String str) {
            //1.遍历字符串
            //2.创建二叉树
            TreeNode root = null;
            if(str.charAt(i)!= '#') {
                root = new TreeNode(str.charAt(i));
                i++;
                root.left = creatTree(str);
                root.right = creatTree(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);
        }
    }

 

Dikz12
关注
  • 29
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 22
    评论
专栏目录
二叉树-基于C语言实现的二叉树基本操作.zip
04-26
二叉树 二叉树_基于C语言实现的二叉树基本操作
二叉树基本操作实现
qq_43710269的博客
04-16 3462
链式二叉树 数组表示二叉树要求二叉树必须是完全二叉树或者是满二叉树，所以二叉树还可以用链式表示其结构代码如下： typedef int DataType; typedef struct BinaryTree{ struct BinaryTree* _left; struct BinaryTree* _right; DataType data; };BTNode 前序遍历 前序遍历的顺序为根，左子树，右子树，所以也被称为先根遍历。 如图以这个二叉树为例： 这
二叉树OJ练习
weixin_60718941的博客
07-18 366
📣大部分关于二叉树的OJ题都涉及分治与递归思想，同时这些也是二叉树的基础，接下来的一些OJ题将这些思想运用的淋漓尽致，相信你看完以后对这种思想也理解的更加深刻同时也能进一步的掌握二叉树的结构。......
[D-OJ练习] 二叉树的基本操作
☆迷茫Dog的秘密基地☆
10-12 610
设计二叉树类，能够对二叉树进行先序、中序、后序和层序遍历，遍历的操作为输出结点的值，设计主函数，输入一棵二叉树，按先序、中序、后序、层序的遍历顺序输出结点的值。二叉树的结点数不超过20。 输入描述 输入数据只有一组, 二叉树的结点均为一个数字， 数据为0代表当前结点为空。输入结点的值按照二叉树的先序遍历顺序, 比如输入： 1 2 4 0 0 5 0 0 3 0 6 0 0，0表示空，输入的数字之间由空格分隔。 输出描述 输出先序、中序、后序和层序遍历二叉树得到的序列，各占一行，同一...
【数据结构】二叉树经典OJ练习
Edward_Asia的博客
11-15 2821
前言 本章只是二叉树的部分简单练习，对于这部分题目大多比较简单，但重要的不是能过OJ，而是深入理解每一道题的解题原理。 多思考，勤动手，才是正解。对于编程，我们要做到画图半小时，写代码五分钟；而不是写代码五分钟，调试三十分钟。 理解递归思想，分治思想，温故而知新~ 1.单值二叉树 单值二叉树 根据题目描述，判断二叉树的每个节点的值是否相同。 方法： 先判断根节点与左右子节点的值是否相等。 进而递归判断左右子树的根节点与左右子节点的值是否相等。 代码如下： bool isU.
二叉树基础oj练习-
Dingyuan0的博客
05-25 142
二叉树 按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历： 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。 题目链接 1.链接: 单值二叉树 2.链接: 相同的树 3.链接: 对称二叉树 4.链接: 二叉树的前序遍历 5.链接: 二叉树
手撕二叉树oj练习
bit_zyx的博客
04-29 776
目录 1、单值二叉树 2、检查两棵树是否相同 3、对称二叉树 4、翻转二叉树 5、二叉树前序遍历 6、二叉树中序遍历 7、二叉树后续遍历 8、另一棵树的子树 9、二叉树的构建及遍历 1、单值二叉树 链接直达： 单值二叉树 题目： 思路： 递归+分治 单值二叉树，顾名思义，就是说所有节点的值val是相同的，这里我们采用分治的思想。具体操作过程是将每个节点都去和根节点比较，如果存在不等，就返回false。如果每个根和其左右孩子都相等，那么我们就可以断定此二叉树必是单值二叉树，...
（C语言）二叉树经典oj题练习
博主qq1077644249
08-16 647
我们先自己定义一个二叉树结构体类型，然后基于分治的思想，递归构建二叉树，构建二叉树先malloc出根节点然后再构建左子树，右子树即可。因为字符串需要构建之后指针向后移动找到下一个字符，所以需要定义一个i下标，通过传址调用把i的地址传过去，实现对下标i的控制。构建之后i下标向后移动，指针指向’#‘代表到了空节点了完成返回NULL即可。如果一个树的左子树与右子树镜像对称，那么这个树是对称的。 > 因此，如果同时满足下面的条件，两个树互为镜像： > 1、它们的两个根结点具有相同的值 > 2、每个树的右子树都与
【数据结构】二叉树的实现&&OJ练习
大三小白C++进阶之路
12-07 1841
二叉树的基本接口函数的实现和一些简单的OJ练习题
二叉树oj练习
m0_75260318的博客
03-18 894
（牛客，力扣题目）
C++实现二叉树基本操作详解
12-26
本学年论文介绍了二叉树的定义，二叉树的存储结构，二叉树的相关术语，以此引入二叉树这一概念，为展开二叉树的基本操作做好理论铺垫。二叉树的基本操作主要包含以下几个模块：二叉树的遍历方法，计算二叉树的结点个...
C语言实现二叉树的基本操作源码.zip
10-30
二叉树
二叉树基本操作
04-30
以二叉链表作存储结构，编写程序，实现如下的功能： 1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为...
二叉树基本操作_二叉树基本操作_
10-02
实现了基本的二叉树算法，利用链表实现，计算树高，插入删除等
二叉树专题（有关二叉树的相关学习）
aaa114514aaaa的博客
05-14 1591
有关二叉树的学习，目前已经学习了大概2/5的样子，后面更加有难度的，比如搜索平衡二叉树，红黑树等知识，将在C++学习。
数据结构之树与二叉树
最新发布
paradiso989的博客
05-20 744
本文介绍了数据结构中树与二叉树的基础概念以及实现方式
【数据结构/C语言】深入理解 双向链表
2302_78391795的博客
05-20 735
双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。 一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。
【数据结构】单链表逆置（详解）————四种方法
lzh20040919的博客
05-17 407
逆置就是把最后一个数据提到最前面，倒数第二个放到第二个……依次类推，直到第一个到最后一个。由于链表没有下标，所以不能借助下标来实行数据的逆置，要靠空间的转移来完成链表的逆置，这里采用没有头节点的链表来实现逆置。
二叉树基本操作的实现
10-25
二叉树是一种非常重要的数据结构，它的基本操作包括创建、销毁、遍历、查找等。下面是二叉树基本操作的实现方法： 1. 创建二叉树：通过前序遍历的数组构建二叉树，其中 '#' 表示空节点。具体实现方法可以参考引用中的 BinaryTreeCreate 函数。 2. 销毁二叉树：遍历二叉树，依次释放每个节点的内存空间。具体实现方法可以参考引用中的 BinaryTreeDestory 函数。 3. 遍历二叉树：二叉树的遍历包括前序遍历、中序遍历、后序遍历和层序遍历。具体实现方法可以参考引用中的 BinaryTreePrevOrder、BinaryTreeInOrder、BinaryTreePostOrder 和 BinaryTreeLevelOrder 函数。 4. 查找二叉树节点：在二叉树中查找值为 x 的节点，具体实现方法可以参考引用中的 BinaryTreeFind 函数。 5. 计算二叉树节点个数：计算二叉树中节点的个数，具体实现方法可以参考引用[2]中的 BinaryTreeSize 函数。 6. 计算二叉树叶子节点个数：计算二叉树中叶子节点的个数，具体实现方法可以参考引用中的 BinaryTreeLeafSize 函数。 7. 计算二叉树第 k 层节点个数：计算二叉树中第 k 层节点的个数，具体实现方法可以参考引用中的 BinaryTreeLevelKSize 函数。 8. 判断二叉树是否是完全二叉树：判断二叉树是否是完全二叉树，具体实现方法可以参考引用中的 BinaryTreeComplete 函数。 9. 计算二叉树的深度：计算二叉树的深度，具体实现方法可以参考引用中的 BinaryTreeDeep 函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值