二叉树相关算法需了解汇总-基础算法操作

最新推荐文章于 2024-10-09 22:28:58 发布
最新推荐文章于 2024-10-09 22:28:58 发布
阅读量555 收藏 13
点赞数 8
分类专栏： 算法刷题 文章标签： 算法 java 数据结构
伟仔
本文链接：https://blog.csdn.net/weixin_42439274/article/details/136142503
版权
文章详细介绍了二叉树的前序、后序、中序、层序遍历方法，以及二叉树的层次遍历倒序、右视图和N叉树的层序遍历，还包括计算二叉树的最大深度和最小深度的解决方案。
摘要由CSDN通过智能技术生成

文章目录

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) {
        List<Integer> res = new ArrayList<>();
        traversal(res,root);
        return res;
    }
    public void traversal(List<Integer> res ,TreeNode root){
        if(root == null){
            return;
        }
        res.add(root.val);
        traversal(res,root.left);
        traversal(res,root.right);
    }
}

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) {
        List<Integer> res = new ArrayList<>();
        traversal(res,root);
        return res;
    }

    public void traversal(List<Integer> list, TreeNode root){
        if(root == null){
            return;
        }
        traversal(list,root.left);
        traversal(list,root.right);
        list.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) {
        List<Integer> res = new ArrayList<>();
        traversal(res,root);
        return res;
    }   
    public void traversal(List<Integer> list,TreeNode root){
        if(root == null){
            return;
        }

        traversal(list,root.left);
        list.add(root.val);
        traversal(list,root.right);
    }
}

102.二叉树的层序遍历

/**
 * 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<>();
        traversal(res,root,0);
        return res;
    }

    public void traversal(List<List<Integer>> list,TreeNode root, int deep){
        if(root == null){
            return;
        }
        if(list.size() < deep+1){
            list.add(new ArrayList<>());
        }

        list.get(deep).add(root.val);
        traversal(list,root.left,deep+1);
        traversal(list,root.right,deep+1);
    }
}

107.二叉树的层次遍历倒序

/**
 * 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<>();
        traversal(res,root,0);
        Collections.reverse(res);
        return res;
    }

    public void traversal(List<List<Integer>> list,TreeNode root,int deep){
        if(root == null){
            return;
        }

        if(list.size() < deep+1){
            list.add(new ArrayList<>());
        }

        list.get(deep).add(root.val);
        traversal(list,root.left,deep+1);
        traversal(list,root.right,deep+1);
    }
}

199.二叉树的右视图

/**
 * 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> rightSideView(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        traversal(res,root,0);
        List<Integer> result = new ArrayList<>();
        for(List<Integer> list:res){
            result.add(list.getLast());
        }

        return result;

    }

    public void traversal(List<List<Integer>> list,TreeNode root,int deep){
        if(root == null){
            return;
        }

        while(list.size() <deep+1){
            list.add(new ArrayList<>());
        }

        list.get(deep).add(root.val);
        traversal(list,root.left,deep+1);
        traversal(list,root.right,deep+1);
    }
}

637.二叉树的层平均值

/**
 * 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<Double> averageOfLevels(TreeNode root) {

        List<List<Integer>> rest = new ArrayList<>();
        List<Double> res = new ArrayList<>();
        traversal(rest,root,0);
 
        for(List<Integer> l :rest){
            res.add(l.stream()
                    .mapToInt(Integer::intValue)
                    .average()
                    .orElse(0));
        }
        return res;
    }

    public void traversal(List<List<Integer>> list,TreeNode root,int deep){
        if(root == null){
            return;
        }
        if(list.size() < deep+1){
            list.add(new ArrayList<>());
        }
        list.get(deep).add(root.val);
        traversal(list,root.left,deep+1);
        traversal(list,root.right,deep+1);
    }
}

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;
    }
};
*/
class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        traversal(res,root,0);
        return res;
    }

    public void traversal(List<List<Integer>> list,Node root,int deep){
        if(root == null){
            return;
        }

        if(list.size() < deep+1){
            list.add(new ArrayList<>());
        }
        list.get(deep).add(root.val);

        for(Node node : root.children){
            traversal(list,node,deep+1);
        }
        
    }
}

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

/**
 * 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> largestValues(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        traversal(res,root,0);
        List<Integer> result = new ArrayList<>();

        for(List<Integer> l : res){
            result.add(l.stream().max(Integer::compare).orElse(0));
        }

        return result;
    }

    public void traversal(List<List<Integer>> list, TreeNode root, int deep){
        if(root == null){
            return;
        }
        if(list.size() < deep+1){
            list.add(new ArrayList<>());
        }

        list.get(deep).add(root.val);
        traversal(list,root.left,deep+1);
        traversal(list,root.right,deep+1);
    }
}

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

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

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

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root == null){
            return root;
        }

        Queue<Node> nodeq = new LinkedList<>();
        nodeq.add(root);
        while(!nodeq.isEmpty()){
            int size = nodeq.size();

            for(int i = 0; i < size; i++){
                Node node = nodeq.poll();
                if(i < size - 1){
                    node.next = nodeq.peek();
                }

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

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

        return root;
    }

}

104.二叉树的最大深度

/**
 * 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 int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }

        int leftH = maxDepth(root.left);
        int rightH = maxDepth(root.right);
        return Math.max(leftH,rightH) + 1;

    }
}

111.二叉树的最小深度

/**
 * 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 int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }

        int leftH = minDepth(root.left);
        int rightH = minDepth(root.right);
        if(leftH == 0 || rightH == 0){
            return Math.max(leftH,rightH) + 1;
        }
        return Math.min(leftH,rightH)+ 1;
    }
}
一个双鱼座的测开
关注
专栏目录
基础算法与数据结构汇总，包括排序、链表、二叉树、图、暴力递归、贪心算法等相关内容.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 一个目标函数...
C语言的算法知识汇总
07-21
数据结构是算法的基础，它包括数据的逻辑结构、存储结构和对数据结构进行的操作。逻辑结构描述的是数据元素之间的逻辑关系，比如线性结构（元素之间是有序的）、树形结构（元素之间有分支层次关系）等。存储结构指的...
【算法设计与分析】期末汇总
05-21
算法设计与分析期末汇总 算法设计基础 算法是指令的有限序列，用于解决特定问题。算法的特性包括输入、输出、有穷性、确定性、可行性、正确性、健壮性、可理解性、抽象分级和高效性。算法的描述方法有自然语言、...
Python算法与设计模式面试题汇总！.docx
06-12
Python算法与设计模式是编程面试中的重要组成部分，对于求职者来说，掌握这些知识不仅可以提升面试成功率，也是在实际工作中解决问题的基础。以下是一些常见的Python算法与设计模式面试问题的详细解答： 1. **顺序...
图论day56|广度优先搜索理论基础 、bfs与dfs的对比（思维导图）、 99.岛屿数量（卡码网）、100.岛屿的最大面积（卡码网）
2402_84438596的博客
10-09 690
图论day56|广度优先搜索理论基础 、bfs与dfs的对比（思维导图）、 99.岛屿数量（卡码网）、100.岛屿的最大面积（卡码网）
[算法] 数组
最新发布
Letmooning的博客
10-09 209
- 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 580
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 381
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 870
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 816
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
生成哈夫曼树
TTz012的博客
10-08 135
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
ICPC-day2(圆方树)
m0_74315028的博客
10-08 210
每次询问两点x, y，求是否存在一个n的排列，使得第一个元素为x，最后一个元素为y，且排列的任意一个前缀、任意一个后缀都连通。可以用圆方树缩点将其变成一颗树，再判断这颗树是否是一条链，x,y是否在这条链的两侧。其实就是求这两个点是否存在两个不相同的路径，同时两者路径的交集是n。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 812
排序是将多个数据，依指定的顺序进行排列的过程。
【旋转数组】二分法专题
weixin_45962681的博客
10-08 929
以上两道题我小总结一下，有无重复元素影响的是=加不加，其实第一题也可以加，在无重复元素的时候，开区间加不加其实没所谓，但是当有重复元素的时候，考虑这个很重要我在刚开始学习二分法的时候，背诵的模板的不加等号的if，改的是left，其实我如果照着这个模板写这两道题，就不会错，但是我鬼使神差把不加等号那边改right了，导致一直不过那么可以总结一个有无重复元素通用的模板public:= right){
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 1174
归并排序 in Java
C - Separated Lunch
m0_74304371的博客
10-05 452
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
代码随想录 101. 孤岛的总面积
qq_53524614的博客
10-05 297
dfs版本，在之前求总面积的基础上增加了判断是否有有边缘位置元素的部分，所以增加了一个notEdge变量，在遇到边缘元素时标记为0，以使所有输出均变为0，此外需要注意，即使遇到了边缘元素也需要先将所有陆地遍历并在visit上标记。毕竟做人需要有始有终）bfs的版本，bfs不需要做递归回溯，所以函数的变量还是不变，只需要在内部增加一个标记是否有边缘元素的变量即可。
算法：双指针系列（二）——对撞指针
2301_81454749的博客
10-09 268
分享有趣的题目，算法技巧
16.最接近的三数之和
weixin_61695887的博客
10-04 315
与三数之和的题类似，首先对数组进行排序。排序后的数组使得我们可以有效地使用双指针法来找到和最接近目标值的三元组。：遍历结束后，返回最接近的三元组的和。，然后通过双指针法来寻找另外两个数。：遍历排序后的数组，固定一个数。中选出三个整数，使它们的和与。假定每组输入只存在恰好一个解。使得三数之和最接近目标值。
二叉树算法详解与实战
"二叉树算法汇总，包括以二叉树表示算术表达式和顺序存储的二叉树处理" 二叉树是一种重要的数据结构，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在计算机科学中，二叉树算法广泛应用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一个双鱼座的测开

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值