Letcode-Top 100二叉树专题

丘山一郎2024-06-09 23:28

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> arraylist=new ArrayList<>();
        if(root==null){
            return arraylist;
        }

        Stack<TreeNode> stack=new Stack<TreeNode>();
        TreeNode current=root;
        while(current!=null||!stack.isEmpty()){
            while(current!=null){
                stack.push(current);
                current=current.left;
            }
            current=stack.pop();
            arraylist.add(current.val);
            current=current.right;


        }
        return arraylist;
    }
}

方法二：迭代法

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<Integer>();
        inorderTraversal(root, res);
        return res;
    }

    public void inorderTraversal(TreeNode node, List<Integer> res) {
        if (node == null) {
            return;
        }

        inorderTraversal(node.left, res);
        res.add(node.val);
        inorderTraversal(node.right, res);

    }

}

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;
        }else {
            int leftLength = maxDepth(root.left)+1;
            int rightLength = maxDepth(root.right)+1;
            return Math.max(leftLength,rightLength);
        }

    }
}

方法二：层序遍历

java 复制代码 
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        int ans = 0;
        int size = 0;
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()) {
            size = queue.size();
            while (size > 0) {
                root = queue.poll();
                if (root.left != null) {
                    queue.offer(root.left);
                }
                if (root.right != null) {
                    queue.offer(root.right);
                }
                size--;
            }
            ans++;
        }

        return ans;

    }
}

226. 翻转二叉树

方法一：递归

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;
        }else {
            int leftLength = maxDepth(root.left)+1;
            int rightLength = maxDepth(root.right)+1;
            return Math.max(leftLength,rightLength);
        }

    }
}

方法二：迭代

java 复制代码 
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

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

        int size = 0;
        while (!queue.isEmpty()) {
            size = queue.size();
            while (size > 0) {
                TreeNode temp = queue.poll();
                TreeNode left = temp.left;
                if (left != null) {
                    queue.offer(left);

                }
                TreeNode right = temp.right;
                if (right != null) {
                    queue.offer(right);

                }
                temp.left = right;
                temp.right = left;
                size--;
            }
        }
        return root;

    }
}

101. 对称二叉树

方法一：递归

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 boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        return isSymmetric(root.left,root.right);

    }



        public boolean isSymmetric(TreeNode left,TreeNode right) {
            if(left==null&&right==null){
                return true;
            }

            if(left==null|| right==null){
                return false;
            }

            if(left.val!=right.val){
                return false;
            }


            return isSymmetric(left.left,right.right)&& isSymmetric(left.right,right.left);

        }

}

方法二：迭代

java 复制代码 
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        return isSymmetric(root.left, root.right);

    }

    public boolean isSymmetric(TreeNode left, TreeNode right) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(left);
        queue.offer(right);

        while (!queue.isEmpty()) {
            left = queue.poll();
            right = queue.poll();

            if (left == null && right == null) {
                continue;
            }

            if (left == null || right == null || left.val != right.val) {
                return false;
            }

            queue.offer(left.left);
            queue.offer(right.right);

            queue.offer(left.right);
            queue.offer(right.left);

        }

        return true;

    }

}

543. 二叉树的直径

方法一：递归

java 复制代码 
class Solution {
    int ans = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        diameterOfBinaryTreePLus(root);
        return ans;


    }


    public int diameterOfBinaryTreePLus(TreeNode root) {
        if(root==null){
            return 0;
        }

        int left =  diameterOfBinaryTreePLus(root.left);
        int right = diameterOfBinaryTreePLus(root.right);
        ans = Math.max(ans,left+right);
        
        return Math.max(left+1,right+1);


    }
}

102. 二叉树的层序遍历

java 复制代码 
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if (root == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int size = 0;
        while (!queue.isEmpty()) {
            size = queue.size();
            List<Integer> list = new ArrayList<Integer>();

            while (size > 0) {
                TreeNode node = queue.poll();
                list.add(node.val);

                if (node.left != null) {
                    queue.offer(node.left);
                }

                if (node.right != null) {
                    queue.offer(node.right);
                }

                size--;

                if (size == 0) {
                    result.add(list);
                }

            }

        }

        return result;

    }
}

108. 将有序数组转换为二叉搜索树

java 复制代码 
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return sortedArrayToBST(nums,0,nums.length-1);
    }


    public TreeNode sortedArrayToBST(int[] nums,int left,int right){
        if(left>right){
            return null;
        }

        int mid = (left+right)/2;

        TreeNode root = new TreeNode(nums[mid]);
        root.left =  sortedArrayToBST(nums,left,mid-1);
        root.right = sortedArrayToBST(nums,mid+1,right);
        return root;

    }
}

98. 验证二叉搜索树

方法一：递归

初始错误写法

java 复制代码 
class Solution {
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }

        if (root.left != null) {
            if (root.left.val >= root.val) {
                return false;
            }
        }

        if (root.right != null) {
            if (root.right.val <= root.val) {
                return false;
            }
        }

        boolean left = isValidBST(root.left);
        boolean right = isValidBST(root.right);
        return left && right;

    }
}

正确写法

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * long val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(long val) { this.val = val; }
 * TreeNode(long val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }

        return isValidBSTPlus(root,Long.MIN_VALUE,Long.MAX_VALUE);

    }


    public boolean isValidBSTPlus(TreeNode root,long min,long max) {
        if (root == null) {
            return true;
        }

        if (root.left != null) {
            if (root.left.val >= root.val) {
                return false;
            }
        }

        if (root.right != null) {
            if (root.right.val <= root.val) {
                return false;
            }
        }

        if(root.val>=max || root.val<=min){
            return false;
        }

        boolean left = isValidBSTPlus(root.left,min,root.val);
        boolean right = isValidBSTPlus(root.right,root.val,max);
        return left && right;

    }
}

方法二：中序遍历

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 boolean isValidBST(TreeNode root) {

        long limit = Long.MIN_VALUE;

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode currentNode = root;
        while (currentNode != null || !stack.isEmpty()) {
            while (currentNode != null) {
                stack.push(currentNode);
                currentNode = currentNode.left;
            }

            currentNode = stack.pop();
            if (currentNode.val <= limit) {
                return false;
            }

            limit = currentNode.val;
            currentNode = currentNode.right;
        }

        return true;

    }
}
相关推荐
DogDaoDao15 小时前
LeetCode 算法：二叉树中的最大路径和 c++
c++·算法·leetcode·二叉树·二叉树路径
DogDaoDao2 天前
LeetCode 算法：二叉树的最近公共祖先 III c++
数据结构·c++·算法·leetcode·二叉树·最近公共祖先
一直学习永不止步5 天前
LeetCode题练习与总结：二叉树的后序遍历--145
java·算法·leetcode·二叉树·树·栈·深度优先搜索
程序无涯海12 天前
算法篇-二叉树
java·算法·二叉树·笔试·树·算法题
DogDaoDao15 天前
LeetCode 算法：对称二叉树 c++
数据结构·c++·算法·leetcode·二叉树·对称二叉树·递归法
向上爬的卓卓卓17 天前
数据结构【二叉树】
c语言·数据结构·算法·二叉树·oj题目
抖音上游泳的鱼22 天前
Leetcode 力扣117. 填充每个节点的下一个右侧节点指针 II (抖音号：708231408)
数据结构·python·算法·leetcode·职场和发展·二叉树
依旧风轻23 天前
104. 二叉树的最大深度
ios·二叉树·swift·dfs·bfs
这个人懒得名字都没写1 个月前
树&二叉树
c语言·数据结构·c++·二叉树·树
热门推荐
012024年江苏省研究生数学建模科研创新实践大赛C题气象数据高精度融合技术研究论文和代码分析02Coze扣子平台完整体验和实践（附国内和国际版对比）03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）042024亚太赛（中文赛）数学建模竞赛选题建议+初步分析05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【经验分享】Ubuntu22.04安装微信(linux官方版)072024 年第十四届 APMCM 亚太地区大学生数学建模竞赛B题超详细解题思路+数据预处理问题一代码分享082025张宇考研数学，百度网盘视频课+36讲PDF讲义+真题09【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解10通用大模型VS垂直大模型，你更青睐哪一方？