07-二叉树类

已于 2022-07-25 21:00:40 修改
阅读量389 收藏
点赞数
分类专栏： 算法 文章标签： java 算法 开发语言
于 2022-07-14 11:05:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41911251/article/details/125772835
版权

文章目录

二叉树理论基础篇

二叉树的题目分类

就是6种题型，4种二叉树的，6种二叉搜索书的
在这里插入图片描述

二叉树的种类

  • 满二叉树
    如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树
    若深度为k，则2^k-1个节点
    在这里插入图片描述
  • 完全二叉树
    在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点
    在这里插入图片描述
    优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系
  • 二叉搜索树
    二叉搜索树是有数值的了，二叉搜索树是一个有序树
    定义如下：
  • 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  • 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  • 它的左、右子树也分别为二叉排序树
    在这里插入图片描述
  • 平衡二叉搜索树
    平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树
    在这里插入图片描述

二叉树的存储方式

二叉树可以链式存储，也可以顺序存储
在这里插入图片描述

二叉树的遍历方式

深度优先遍历：先往深走，遇到叶子节点再往回走
广度优先遍历：一层一层的去遍历

在这里插入图片描述

前中后，其实指的就是中间节点的遍历顺序

在这里插入图片描述

在这里插入图片描述
栈和队列可以分别遍历深度优先遍历与广度优先遍历

二叉树的定义

public class TreeNode {
    int val;
  	TreeNode left;
  	TreeNode right;
  	TreeNode() {}
  	TreeNode(int val) { this.val = val; }
  	TreeNode(int val, TreeNode left, TreeNode right) {
    		this.val = val;
    		this.left = left;
    		this.right = right;
  	}
}

题目

二叉树的递归遍历

递归方法论：
在这里插入图片描述
以下以前序遍历为例：
在这里插入图片描述
熟练的记住递归法的方法论，在递归的路上越走越稳！！！

144. 二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> Arr = new ArrayList<Integer>();
        Traversal(root,Arr);
        return Arr;
    }

        // 递归三要素
        // 确定递归函数的参数和返回值
        void Traversal(TreeNode root,ArrayList<Integer> Arr){
            // 确定递归的结束条件
            if(root == null)  return;

            // 确定单层递归逻辑
            Arr.add(root.val);
            Traversal(root.left,Arr);
            Traversal(root.right,Arr);
        
        }
 
}

145. 二叉树的后序遍历


/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> Arr = new ArrayList<Integer>();
        Traversal(root,Arr);
        return Arr;
    }

        // 递归三要素
        // 确定递归函数的参数和返回值
        void Traversal(TreeNode root,ArrayList<Integer> Arr){
            // 确定递归的结束条件
            if(root == null)  return;

            // 确定单层递归逻辑           
            Traversal(root.left,Arr);
            Traversal(root.right,Arr);
            Arr.add(root.val);
        
        }
 
}

94. 二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> Arr = new ArrayList<Integer>();
        Traversal(root,Arr);
        return Arr;
    }

        // 递归三要素
        // 确定递归函数的参数和返回值
        void Traversal(TreeNode root,ArrayList<Integer> Arr){
            // 确定递归的结束条件
            if(root == null)  return;

            // 确定单层递归逻辑           
            Traversal(root.left,Arr);
            Arr.add(root.val);
            Traversal(root.right,Arr);       
        }
 
}

二叉树的迭代遍历

为什么可以用迭代法（非递归的方式）来实现二叉树的前后中序遍历呢？
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因

前序遍历(迭代法)

前序遍历是中左右，每次先处理的是中间节点，那么**先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子**

在这里插入图片描述

// 迭代法

class Solution {
    // 前序遍历顺序   中左右   入栈顺序：中--左----右
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if(root==null) return result;

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if(node.right!=null) stack.push(node.right);
            if(node.left!=null) stack.push(node.left);

        }
        return result;
        }
}

中序遍历(迭代法)

在这里插入图片描述

处理顺序和访问顺序是不一致的

方法：在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素

// 迭代法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if(root==null) return result;

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

        while(cur!=null||!stack.isEmpty()){
            if(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }else{
                cur=stack.pop();
                result.add(cur.val);
                cur=cur.right;
            }
        }
        return result;         
        } 
}

后序遍历(迭代法)

在这里插入图片描述

// 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

二叉树层序遍历

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）
在这里插入图片描述
思路：
此题做过一次，但是还是做不出来，主要原因忽视了循环里面还应该有一个循环，用来规定这个每个数组的长度

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root==null) return res;

        Queue<TreeNode> que = new LinkedList<>();

        que.add(root);

        while(!que.isEmpty()){
            List<Integer> arr = new ArrayList<>();
            int len =que.size();

            while(len>0){
                 TreeNode tre = que.poll();
                 arr.add(tre.val);

                 if(tre.left!=null) que.add(tre.left);
                 if(tre.right!=null) que.add(tre.right);

                 len--;
            }
            res.add(arr);
        }

        return res;
    
    }

}

学习：先把该建的数据结构，先建好，里面的循环画图，一步一步模拟实现

107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

在这里插入图片描述
思路：
先做一下层次遍历，然后把得到的二维数组，反转一下

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;

        Queue<TreeNode> que = new LinkedList<>();
        que.add(root);

        while(!que.isEmpty()){
            List<Integer> arr = new ArrayList<>();
            int len = que.size();

            while(len>0){
                TreeNode tre = que.poll();
                arr.add(tre.val);
                
                if(tre.left!=null) que.add(tre.left);

                if(tre.right!=null) que.add(tre.right);
                
                len--;
            }
            res.add(arr);
        }   

        List<List<Integer>> res2 = new ArrayList<>();

        for(int i = res.size()-1;i>=0;i--){
            res2.add(res.get(i));
            
        }  
        return res2;
    }
}

学习：思路是挺好想的，但是操作时出现了弱智错误是：先将右支放进了队列，然后又放的左支

199. 二叉树的右视图

此题就两个思路，思路1：在往数组里加的时候，确定是不是len=1，如果等于1，则加进去，不等于1，不加
思路2：先求出二维数组，然后求每个数组的最后一个

637.二叉树的层平均值

此题实际上和上一题类似，思路1：就是在如何加入数组的时候进行平均操作；
思路2：就是就是先求出二维数组，然后再求每个数组的平均值

用思路2左，做了1个半小时，才做出出来，遇到了好多弱智错误：
每一次都需要新建一维数组，每一次都需要，往外弹，这些语句应该放在那个循环内，需要重视
再就是每次循环完需要将平均值av调成0，不然把以前的数也加上了
最后要注意，root能不能为null，白和傻逼一样，直接判空
要学会调试，很多问题已调试就出来了

这样做时间复杂度8%特别低，效果不是很好

用思路1做，做了接近15分钟吧，出现的问题是：将len作为了求平均数的个数，导致数组li里面全是NAN，需要自己信息新增一个count进行计数，然后让他作为被除数
再就是要保证平均数为实数，所以需要将其强转，或者让一个类型成为实数类型，避免了强转

时间复杂度达到95%，这个方法效果好很多，而且也避免了新建很多动态数组

429. N 叉树的层序遍历

在这里插入图片描述

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};

此题肯定是根据N叉树的定义做的，这样也不用判断左右树，直接用Children的子类，如果子类不等于空则进行加入到数组，应该是这样

此题大约做了20分钟，实际上改的就是如何往队列中加指针的问题，先求tre的孩子集合，先判断集合有没有问题，如果没有，就进行遍历求各个孩子，如果孩子没问题，就加进队列，就是这样的一个逻辑吧
在这里插入图片描述
集合的判断实际上有一个就行！！！

515. 在每个树行中找最大值

在这里插入图片描述
思路1：还是最简单的方法，就是求出二位数组，然后再求各一维数组的最大值，但此方法不是好方法

思路2：就是在往一维数组加元素时，需要和以前的判断，如果大就替换掉他，一直替换到最后一个，那就是最大的

思路1：做出来了，大约做了24分钟左右，出现的问题主要就是求最大值，设置最小值的API有点忘了，试了试试出来了，再就是出现的些弱智错误，都是每次报错后，根据报错的信息调对的
时间复杂度比较低，才9.05%

思路2：哎，真菜，什么错也出，调了接近30分钟，才挑出来，用的思路1的代码，结果每次都创建一个一维数组，产生了错误，研究了10几分钟，也没看出哪里错，这是奇葩，再就是当len=0的时候，才需要将max加入到arr中，而不是len =1

时间复杂度也不是很高，78%

116. 填充每个节点的下一个右侧节点指针

在这里插入图片描述
思路：
队列弹出值，值的指针指向队列的顶部

做了20分钟，没做出来，上面想的思路，不对，要保证len-1大于0才行，因为已经弹出1个元素，此时len为进行减1，需要在减1之后，队列中还有元素，才行！
为什么返回node而不是root呢？
node是最后一个元素，而root是第一个元素，后面连接着一大串

117.填充每个节点的下一个右侧节点指针II

与上一题的区别是非完美二叉树
在这里插入图片描述

104.二叉树的最大深度

在这里插入图片描述

  1. 思路: 先用层序遍历求二维数组，再求二维数组的大小，就是深度
  2. 思路: 记录一个深度数为0，len 不是大于0时，深度数 + 1
  3. 采用深度遍历应该也可以

111.二叉树的最小深度

在这里插入图片描述
思路: 当一节点的左右子树都为空时，返回当前深度，没有都为空的情况，则返回正常深度

226. 翻转二叉树

在这里插入图片描述
1.思路: 递归法： 到左节点，到右节点，然后进行交换即可【前后遍历】
2. 思路 层序遍历 直接得到二维数组，然后在进行一维数组的反转，并放进一维数组中
3. 思路: 不用队列，放进栈中应该也不错

101. 对称二叉树

灵动鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法+Python - 二叉树
编码时光
05-07 155
二叉树 二叉树的基本概念 二叉树的性质(特性) 完全二叉树 满二叉树 二叉树的节点表示以及树的创建 二叉树的遍历 深度优先遍历 先序遍历 中序遍历 后序遍历 广度优先遍历(层次遍历)
三维点云处理07-二叉树
m0_45388819的博客
05-28 201
三维点云处理07-创建二叉树 python实现二叉树的构建 import numpy as np # 节点定义 class Node: def __init__(self, key, value = -1): self.left = None self.right = None self.key = key self.value = value # 递归创建二叉树 def insert(root, key ,value): if root is None: root = No
2021-07-22 二叉树-python
qq_46057218的博客
07-22 107
二叉树 用list形式表示二叉树吧btree[0]表示结点数据，btree[1]表示左子树，btree[2]表示右子树。里面就是列表套列表……这里完全没必要用类了，就用一些方法就行了，构造成一个类挺麻烦的，应该也能行。 def BinTree(data, left=None, right=None): return [data, left, right] def is_empty_BinTree(btree): return btree is None def root(btree)
二叉树--
2303_77155762的博客
05-03 46
如果进行多次比较, 大小在变化，或与目标结果有关的其他结果，或是二分法构造节点的左右子树, 是指都是跟节点有关, 当节点发生变化时, 这些情况跟着变因此要重新设立新的内部类, 会更加便于使用。
#08 二叉树
挖洞的杰瑞的博客
10-01 194
参考答案看底部 1.数据结构【二叉树】 先序遍历的顺序建立二叉链表 题目描述 编写函数实现 先序遍历的顺序建立二叉链表 注意：提交程序时需提交完成的程序代码 前置代码： //算法5.3 先序遍历的顺序建立二叉链表 #include using namespace std; //二叉树的二叉链表存储表示 typedef struct BiNode { char data; //结点数据域 struct BiNode *lchild,*rchild; //左右孩子指针 }BiTNode,*BiTree; v.
算法基础08-二叉树的递归思维
weixin_42503072的博客
03-30 366
文章目录1 二叉树的递归套路1.1 二叉树的递归套路深度实践1.1.1 例一：判断二叉树平衡与否.1.2 例二：返回二叉树任意两个节点最大值1.1.3 例三：返回二叉树中的最大二叉搜索树Size1.1.4 例四：派对最大快乐值1.1.5 例五：判断二叉树是否是满二叉树1.1.6 例六：二叉搜索树的头结点1.1.7 例子七：是否是完全二叉树1.1.8 例子八：最低公共祖先 1 二叉树的递归套路 1、 可以解决面试中的绝大部分二叉树(95%以上)的问题，尤其是树形dp问题 2、 其本质是利用递归遍历二叉树的便利
python 读取内存二叉树_二叉树类python
weixin_39729115的博客
12-21 358
python中的树数据结构线性数据中的典型顺序表和链表已经讲完：《顺序表数据结构在python中的应用》《python实现单向链表数据结构及其基本方法》《python实现单向循环链表数据结构及其方法》《python实现双向链表基本结构及其基本方法》《python实现双向循环链表基本结构及其基本方法》《pytho...文章python之战2019-04-101338浏览量python数据结构与算法总...
20151910042-刘鹏-DSA思考题-07 - iterator and tree1
08-08
4. (1) 构造一棵树，每个内节点的子节点高度相等，可以创建一个完全平衡的树，例如完全二叉树。 (2) 构造一棵树，每个内节点的子节点高度差最多为1，这可以是AVL树或红黑树等自平衡二叉搜索树。 5. 遍历计算是指...
leetcode分类-Algorithm-Practice-EveryWeek:Algorithm-Practice-EveryWeek-算法
06-30
2019-12-07-二叉树深度遍历 Leetcode 107 2019-12-09-Leet232-栈实现队列出入栈 Leetcode 232 考察栈和队列 2019-12-11-Leetcode347-优先队列TopK Leetcode 347【难度中等】 考查二叉堆，优先队列 2019-12-12-全排列...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 1013
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
最新发布
qq_3512323979的博客
08-26 1020
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 1430
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1982
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 1769
linux上datax 安装以及使用
基于jenkins部署maven项目
静水深流
08-26 752
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 1145
@Transactional中使用线程锁导致了锁失效与解决方案
Java学习_18_Stream流
qq_41136689的博客
08-23 1568
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 471
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
期权定价-二叉树python
09-25
期权定价模型中的二叉树是一种常用的方法。它可以在给定期权条件和市场数据的情况下，通过构建二叉树来估计期权的价格。该模型的实现包括以下两个主要步骤：1. 从左到右生成二叉树，即根据期权到期时间和时间步长，构建一个二叉树结构；2. 从右向左计算二叉树上各节点的期权价值，即根据期权的特定定价公式和二叉树结构，逆向计算期权的价值。 在Python中，可以通过编写相应的代码来实现二叉树期权定价模型。具体实现的步骤包括：1. 定义二叉树的节点类；2. 构建二叉树结构；3. 根据期权定价公式计算二叉树上各节点的期权价值。 在实现过程中，可以利用Python中的数据结构和算法库，如列表、循环语句、递归等，来简化代码的编写过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值