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

糖果店的幽灵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;
    }
}
相关推荐
好学且牛逼的马5 分钟前
MyBatis-Plus的深度解析
java
苏纪云6 分钟前
数据结构＜C++＞——数组
java·数据结构·c++·数组·动态数组
周杰伦_Jay15 分钟前
【 RocketMQ 全解析】分布式消息队列的架构、消息转发与快速实践、事务消息
分布式·算法·架构·rocketmq·1024程序员节
典则28 分钟前
STM32FreeRtos入门(五)——同步互斥与通信
java·jvm·stm32
sprintzer28 分钟前
10.16-10.25力扣计数刷题
算法·leetcode
你不是我我28 分钟前
【Java 开发日记】我们来讲一讲阻塞队列及其应用
java·开发语言
互联网中的一颗神经元30 分钟前
小白python入门 - 9. Python 列表2 ——从基础操作到高级应用
java·开发语言·python
大厂码农老A34 分钟前
我带的外包兄弟放弃大厂转正，薪资翻倍入职字节
java·后端·面试
王哈哈^_^36 分钟前
【数据集】【YOLO】【目标检测】建筑垃圾数据集 4256 张，YOLO建筑垃圾识别算法实战训推教程。
人工智能·深度学习·算法·yolo·目标检测·计算机视觉·数据集
摇滚侠42 分钟前
Spring Boot3零基础教程，生命周期监听，自定义监听器，笔记59
java·开发语言·spring boot·笔记
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04Burp与其他安全工具联动及代理设置教程05Linux下V2Ray安装配置指南06GitLab 零基础入门指南：从安装到项目管理全流程07jdk21下载、安装（Windows、Linux、macOS）08Labelme从安装到标注：零基础完整指南09NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南10HTML5 敲击乐：从零搭建交互式前端音乐项目