牛客算法题_二叉树

静若繁花_jingjing2025-09-29 15:22

1. 二叉树前序遍历(重要)

前序遍历：中左右

思路：使用递归

注意点：定义全局变量List存储元素。开始使用数组存储，并作为递归方法的入参，实际结果是正常的，但是提交时通不过，而且数组写法更复杂，需要考虑数组长度等。

java 复制代码 
public class TreeSolution {
    private List<Integer> list = new ArrayList<Integer>();
    public int[] preorderTraversal(TreeNode root) {
        if (root == null) {
            return new int[0];
        }
        getPreorderTraversal(root);

        int[] array = new int[list.size()];
        for(int i = 0; i < list.size(); i++){
            array[i] = list.get(i);
        }
        return array;
    }



    public List<Integer> getPreorderTraversal(TreeNode root) {
        if (root != null) {
            list.add(root.val);
            getPreorderTraversal(root.left);
            getPreorderTraversal(root.right);
        }
        return list;
    }
}

2. 二叉树中序遍历(重要)

java 复制代码 
   
public class TreeSolution {
    private List<Integer> list = new ArrayList<Integer>();

 /**
     * 中序遍历
     * @param root
     * @return
     */
    public int[] inorderTraversal (TreeNode root) {
        if (root == null) {
            return new int[0];
        }
        getInorderTraversal(root);

        int[] array = new int[list.size()];
        for(int i = 0; i < list.size(); i++){
            array[i] = list.get(i);
        }
        return array;
        // write code here
    }


    /**
     * 中序递归  左中右
     * @param root
     * @return
     */
    public List getInorderTraversal(TreeNode root) {
        if (root != null) {
            getInorderTraversal(root.left);
            list.add(root.val);
            getInorderTraversal(root.right);
        }
        return list;
    }
}

3. 二叉树后续遍历(重要)

java 复制代码 
public class TreeSolution {
    private List<Integer> list = new ArrayList<Integer>();
    /**
     * 后续遍历
     * @param root
     * @return
     */
    public int[] postorderTraversal (TreeNode root) {
        if (root == null) {
            return new int[0];
        }
        getPostorderTraversal(root);

        int[] array = new int[list.size()];
        for(int i = 0; i < list.size(); i++){
            array[i] = list.get(i);
        }
        return array;
    }



    /**
     * 后序递归  左右中
     * @param root
     * @return
     */
    public List getPostorderTraversal(TreeNode root) {
        if (root != null) {
            getInorderTraversal(root.left);
            getInorderTraversal(root.right);
            list.add(root.val);
        }
        return list;
    }

}

4. 二叉树层次遍历&&分层展示(重要)

注意，最后一层是空集合，空集合不要放到最终结果中。

java 复制代码 
public class Solution {
        private ArrayList<ArrayList<TreeNode>> treeNodes = new ArrayList<ArrayList<TreeNode>>();
    /**
     * 层次遍历
     * @param root
     * @return
     */
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        if (root == null) {
            return new ArrayList<ArrayList<Integer>>();
        }
        ArrayList<TreeNode> arrayList = new ArrayList<TreeNode>();
        arrayList.add(root);
        treeNodes.add(arrayList);
        
        while (arrayList.size() > 0 ){
            arrayList = getLevelTreeNode(arrayList);
        }

        ArrayList<ArrayList<Integer>> numList = new ArrayList<ArrayList<Integer>>();
        for(int i = 0; i < treeNodes.size(); i++){
            ArrayList<Integer> subList = new ArrayList<Integer>();
            for(int j = 0; j< treeNodes.get(i).size();j++){
                TreeNode node = treeNodes.get(i).get(j);
                subList.add(node.val);
            }
               if(subList.size() > 0){
                numList.add(subList);
            }
        }
        return numList;
        // write code here
    }
    
    public ArrayList<TreeNode> getLevelTreeNode(List<TreeNode> upLevelNodes){
        ArrayList<TreeNode> list = new ArrayList<TreeNode>();
        for(int i = 0; i < upLevelNodes.size(); i++){
            TreeNode treeNode = upLevelNodes.get(i);
            if(treeNode.left!= null){
                list.add(treeNode.left);
            }
            if(treeNode.right!= null){
                list.add(treeNode.right);
            }
        }
        treeNodes.add(list);
        return list;
    }

}

5. 二叉树之字形打印

返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）

思路：按照第4题层次遍历后，对奇数行倒序即可

6. 二叉树最大深度(重要)

思路：递归

java 复制代码 
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return leftDepth >= rightDepth ? leftDepth + 1 : rightDepth + 1;
    }

7. 根节点到叶子节点的值和是sum, 判断有无

思路：递归

java 复制代码 
 public boolean hasPathSum (TreeNode root, int sum) {
        if(root == null){
            return false;
        }
        // 注意整个结束条件的判断
        if(sum == root.val && root.left == null && root.right == null){
            return true;
        }
        Boolean leftHas = hasPathSum(root.left, sum-root.val);
        Boolean rightHas = hasPathSum(root.right, sum-root.val);
        if(leftHas || rightHas){
            return true;
        }
        return false;
    }

8. 中序遍历结果转成双向链表

思路：

  1. 中序遍历放到一个集合中

  2. 遍历集合元素，修改左右指针

9. 对称二叉树（重要）

思路1：

利用递归思想， 每个节点都比较它的左子树和有子树， 只不过，比较的是node.left = node.right

java 复制代码 
public class Solution {
    boolean a = true;
    
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pRoot TreeNode类
     * @return bool布尔型
     */
        public boolean isSymmetrical(TreeNode pRoot) {
        if (pRoot == null) return a;
        calSymmetrical(pRoot.left, pRoot.right);
        return a;
    }

    void calSymmetrical(TreeNode b, TreeNode c) {
        // 比较当前节点
        if (b == null && c == null) {
            return;
        }
        if (b != null && c == null || b == null && c != null) {
            a = false;
            return;
        }
        if (b.val != c.val) {
            a = false;
            return;
        }
        // 比较当前节点的子节点，只不过是b.left与c.right比较
        calSymmetrical(b.left, c.right);
        calSymmetrical(b.right, c.left);
        return;
    }


}

思路2：

  1. 层次遍历，如果节点的左节点或右节点null, 也放入到层级的集合中

  2. 判断这一层的集合元素是否都为空，都为空，将这层的集合置为空集合

  3. 遍历每一层的集合， 对一层集合元素左对称判断

缺点很明显，代码写起来太多了！

java 复制代码 
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    private ArrayList<ArrayList<TreeNode>> treeNodes = new
    ArrayList<ArrayList<TreeNode>>();

    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pRoot TreeNode类
     * @return bool布尔型
     */
    public boolean isSymmetrical (TreeNode pRoot) {
        if (pRoot == null) {
            return true;
        }
        ArrayList<TreeNode> arrayList = new ArrayList<TreeNode>();
        arrayList.add(pRoot);
        treeNodes.add(arrayList);

        while (arrayList.size() > 0) {
            arrayList = getLevelTreeNodeWithNUll(arrayList);
        }

        for (int i = 0; i < treeNodes.size(); i++) {
            List<TreeNode> nodes =  treeNodes.get(i);
            for (int j = 0; j < nodes.size() / 2; j++) {
                // 空节点的值记为-10000
                int v1 = nodes.get(j) != null ? nodes.get(j).val : -10000;
                int v2 = nodes.get(nodes.size() - j - 1 ) != null ? nodes.get(
                             nodes.size() - j - 1 ).val : -10000;

                if (v1 != v2) {
                    return false;
                }
            }
        }
        return true;
    }


    /**
     * 层次遍历, 如果是null节点也记录
     *
     * @param
     * @return
     */
    public ArrayList<TreeNode> getLevelTreeNodeWithNUll(List<TreeNode>
            upLevelNodes) {
        ArrayList<TreeNode> list = new ArrayList<TreeNode>();
        Boolean res =  upLevelNodes.isEmpty();
        if (allNullNode(upLevelNodes)) {
            return list;
        }

        for (int i = 0; i < upLevelNodes.size(); i++) {
            TreeNode treeNode = upLevelNodes.get(i);
            if (treeNode != null) {
                list.add(treeNode.left);
                list.add(treeNode.right);
            } else {
                list.add(null);
                list.add(null);
            }

        }
        if (!allNullNode(list)) {
            treeNodes.add(list);
            return list;
        } else {
            return new ArrayList<TreeNode>();
        }
    }

    public Boolean allNullNode(List<TreeNode>  list) {
        for (TreeNode node : list) {
            if (node != null) {
                return false;
            }
        }
        return true;
    }



}
相关推荐
仰泳的熊猫3 小时前
LeetCode:496. 下一个更大元素 I
数据结构·c++·算法·leetcode
未知陨落3 小时前
LeetCode:78.跳跃游戏
算法·leetcode
Wenhao.4 小时前
LeetCode-Hot100 最小栈实现
算法·leetcode
闲人编程4 小时前
会议安排问题之贪心算法
python·算法·ios·贪心算法·会议问题·算法改进·codecapsule
Jiezcode4 小时前
LeetCode 48. 旋转图像
c++·算法·leetcode·职场和发展
Greedy Alg4 小时前
LeetCode 230. 二叉搜索树中第 K 小的元素
算法·leetcode·职场和发展
rannn_1115 小时前
【LeetCode hot100|Week4】链表
后端·算法·leetcode·链表
种自己的花呀5 小时前
LeetCode 53 最大子数字和（动态规划）
算法·leetcode·动态规划
Craaaayon5 小时前
【数据结构】二叉树-图解深度优先搜索(递归法、迭代法)
java·数据结构·后端·算法·leetcode·深度优先
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南03UV安装并设置国内源04阿里最新开源Wan2.2-Animate-14B 本地部署教程：统一双模态框架，MoE架构赋能电影级角色动画与替换05Spec-Kit 使用指南06Linux下V2Ray安装配置指南0746个Nano-banana 精选提示词，持续更新中08OpenSpeedy简介09KGG转MP3工具|非KGM文件|解密音频10VsCode远程Copilot无法使用Claude Agent问题