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

糖果店的幽灵2024-02-22 23:26

文章目录

144.二叉树的前序遍历

java 复制代码 
/**
 * 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.二叉树的后序遍历

java 复制代码 
/**
 * 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.二叉树的中序遍历

java 复制代码 
/**
 * 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.二叉树的层序遍历

java 复制代码 
/**
 * 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.二叉树的层次遍历倒序

java 复制代码 
/**
 * 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.二叉树的右视图

java 复制代码 
/**
 * 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.二叉树的层平均值

java 复制代码 
/**
 * 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);
    }
}
java 复制代码

429.N叉树的层序遍历

java 复制代码 
/*
// 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.在每个树行中找最大值

java 复制代码 
/**
 * 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.填充每个节点的下一个右侧节点指针

java 复制代码 
/*
// 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.二叉树的最大深度

java 复制代码 
/**
 * 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.二叉树的最小深度

java 复制代码 
/**
 * 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;
    }
}
相关推荐
m0_5873830040 分钟前
广州 24 小时自助健身房解决方案技术实现与实战指南
java·spring·小程序·架构·需求分析
mmmmath_31 小时前
LeetCode.199.二叉树的右视图
数据结构·leetcode
·云扬·1 小时前
Prompt 工程与安全：从 System 设计到注入防御
java·人工智能·安全·ai·prompt
专注仿真1 小时前
引擎扩展性与集成设计深度剖析：从 14 个扩展点到 DIS→HLA 演进之路
开发语言·算法·仿真引擎·推演引擎
码爸1 小时前
支持向量机介绍与示例
算法·机器学习·支持向量机
怕浪猫1 小时前
2028编程圈很火的10个Skills
算法·面试·github
代码不停2 小时前
自动化测试（java）
java·开发语言·selenium·自动化
鬼手点金4 小时前
opencode-rules 插件
java·开发语言·前端·人工智能·chrome·git·github
paopaokaka_luck5 小时前
滑雪场管理系统（AI智能助手流式对话，ECharts 运营数据分析、教练、雪具与场地一体化预约，钱包支付退款、订单核销与服务评价）
java·人工智能·spring boot·网络协议·数据分析·echarts
Wang's Blog5 小时前
Java 项目实战: 交友项目 - Dubbo 的内部结构与一次调用的完整链路
java·dubbo
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02历年考研数学一、数学二、数学三真题试卷及答案PDF03GitHub 镜像站点04「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接06如何新建文件夹？ 电脑新建文件夹的4种方法07Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）08轻量化AI渗透武器库｜ARTEX自主攻防系统、资产梳理、漏洞挖掘、链路分析全流程智能化落地09Telegram APK 下载安装完整指南 — 2026年最新10微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新