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

糖果店的幽灵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;
    }
}
相关推荐
天河归来9 小时前
第三方接口不稳定，如何让核心任务继续完成
java·大数据
Knight_AL9 小时前
Java 文件下载时文件名中的 `#` 被转换成 `%23`？一次 URL 编码与解码问题排查
java·开发语言
ZhengEnCi10 小时前
GPT-6 Astra 爆改 Qwen 权重真有那么神吗：权重空间编程 0.016% 参数的真相
算法·架构
罗西的思考10 小时前
【轻量化复刻大模型 / KIMI K3】KDA（Kimi Delta Attention）：并行
人工智能·算法·机器学习
砚底藏山河10 小时前
python量化自定义周期 K 线合成
java·开发语言·数据库·python·金融
猿究院_夏燊11 小时前
MySQL 的四种隔离级别
java·数据库·mysql
码流子12 小时前
移动收费怎么做？手持终端+App+收费中心的架构实践
java·开发语言·架构
霸道流氓气质12 小时前
AI 流式对话与实时聊天平台：SSE 解码竞态、有状态会话隔离与背压取消的 Vue3 + Spring AI 生产级实战
java·人工智能·spring
夜不会漫长12 小时前
C++：红黑树
数据结构·算法
云创智城-yuncitys12 小时前
YunParking 4.0：JDK 17 与 Spring Boot 3.2 的停车云升级
java·开发语言·spring boot
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02历年考研数学一、数学二、数学三真题试卷及答案PDF03GitHub 镜像站点04几个好用的ip纯净度检测网站05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接06苹果iPA游戏软件资源下载网站07如何新建文件夹？ 电脑新建文件夹的4种方法08昇腾910B系列芯片完全指南：四款型号对比、服务器选型与大模型部署实战09Dify：一站式AI应用开发平台全解析与Windows部署指南10Android 屏幕适配系列开篇：核心概念、官方机制与主流方案