二叉树 on Coder_Studio

手撕真题-计算二叉树中两个节点之间的距离

Wed, 11 Mar 2026 22:26:31 +0000

思路

求解代码

 public class TreeDistance {

        /**
         * 计算两个节点在二叉树中的距离
         *
         * @param root 二叉树的根节点
         * @param p    第一个节点
         * @param q    第二个节点
         * @return 两个节点之间的距离
         */
        public int distanceBetweenNodes(TreeNode root, TreeNode p, TreeNode q) {
            // 首先找到两个节点的最近公共祖先(LCA)
            TreeNode lca = findLCA(root, p, q);
            // 计算节点p到LCA的深度
            int depthP = findDepth(lca, p);
            // 计算节点q到LCA的深度
            int depthQ = findDepth(lca, q);
            // 两个节点之间的距离等于它们到LCA的深度之和
            return depthP + depthQ;
        }

        /**
         * 查找二叉树中两个节点的最近公共祖先(LCA)
         *
         * @param root 二叉树的根节点
         * @param p    第一个目标节点
         * @param q    第二个目标节点
         * @return 最近公共祖先节点，如果其中一个节点是根节点，则返回该节点；如果两个节点分别在左右子树中，则返回它们的根节点
         */
        private TreeNode findLCA(TreeNode root, TreeNode p, TreeNode q) {
            // 如果根节点为空，或者根节点是p或q中的一个，直接返回根节点
            if (root == null || root == p || root == q) {
                return root;
            }
            // 递归查找左子树中的LCA
            TreeNode left = findLCA(root.left, p, q);
            // 递归查找右子树中的LCA
            TreeNode right = findLCA(root.right, p, q);
            // 如果左右子树都找到了非空节点，说明p和q分别在左右子树中，当前节点就是LCA
            if (left != null && right != null) {
                return root;
            }
            // 如果左子树找到非空节点，则返回左子树的结果，否则返回右子树的结果
            return left != null ? left : right;
        }


        /**
         * 查找目标节点在给定祖先节点下的深度
         *
         * @param ancestor 起始祖先节点
         * @param target   目标节点
         * @return 目标节点相对于祖先节点的深度，如果未找到则返回-1
         */
        private int findDepth(TreeNode ancestor, TreeNode target) {
            // 如果祖先节点为空，说明无法找到目标节点，返回-1
            if (ancestor == null) {
                return -1;
            }
            // 如果当前节点就是目标节点，深度为0
            if (ancestor == target) {
                return 0;
            }
            // 递归查找左子树
            int left = findDepth(ancestor.left, target);
            // 如果在左子树中找到目标节点，返回左子树深度+1
            if (left != -1) {
                return left + 1;
            }
            // 递归查找右子树
            int right = findDepth(ancestor.right, target);
            // 如果在右子树中找到目标节点，返回右子树深度+1，否则返回-1
            return right != -1 ? right + 1 : -1;
        }
    }

BISHI96 先序遍历、中序遍历和后序遍历

Sat, 07 Mar 2026 19:38:45 +0000

思路

求解代码

// 使用数组模拟指针，lc[i] 存储节点 i 的左孩子，rc[i] 存储右孩子
    private static int[] lc, rc;

    // 使用 StringBuilder 缓存结果
    private static StringBuilder preOrder = new StringBuilder();
    private static StringBuilder inOrder = new StringBuilder();
    private static StringBuilder postOrder = new StringBuilder();

    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine().trim());

        // 边界情况：空树
        if (n == 0) {
            return;
        }

        // 初始化结构：n+1 长度是为了匹配从 1 开始的节点编号
        lc = new int[n + 1];
        rc = new int[n + 1];
        boolean[] hasParent = new boolean[n + 1]; // 用于寻找根节点（根节点没有父节点）

        // 使用邻接表暂时存储“父 -> 子”的原始指向关系，随后再按规则分配左右
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取 n-1 条边，构建树的层级关系
        for (int i = 0; i < n - 1; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]); // 父节点
            int v = Integer.parseInt(edge[1]); // 子节点
            adj[u].add(v);
            hasParent[v] = true; // 只要被指向，就说明该节点不是根节点
        }

        /**
         * 根据题目定义的规则，将 adj 里的子节点分配到 lc 或 rc
         */
        for (int i = 1; i <= n; i++) {
            // 父节点拥有两个孩子
            if (adj[i].size() == 2) {
                int c1 = adj[i].get(0);
                int c2 = adj[i].get(1);
                // 编号小者为左，大者为右
                lc[i] = Math.min(c1, c2);
                rc[i] = Math.max(c1, c2);
            }
            // 父节点仅有一个孩子
            else if (adj[i].size() == 1) {
                int child = adj[i].get(0);
                // 子节点编号 > 父节点编号 ➜ 视为左孩子；反之 ➜ 视为右孩子
                if (child > i) {
                    lc[i] = child;
                } else {
                    rc[i] = child;
                }
            }
        }

        // 寻找整棵树的唯一根节点
        int root = 1;
        for (int i = 1; i <= n; i++) {
            if (!hasParent[i]) {
                root = i;
                break;
            }
        }

        // 从根节点开始DFS
        traverse(root);

        // 格式化输出
        out.println(preOrder.toString().trim());
        out.println(inOrder.toString().trim());
        out.println(postOrder.toString().trim());

        // 刷新缓冲区确保数据完整写出并关闭流
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 深度优先遍历 (DFS) 方法
     *
     * @param cur 当前正在访问的节点索引
     */
    private static void traverse(int cur) {
        // 基准情形：如果当前节点为 0，说明触碰到了空叶子节点，停止向下延伸
        if (cur == 0) {
            return;
        }

        /**
         * 1. 先序遍历 (Pre-order)：[中] -> 左 -> 右
         * 刚进入当前节点时立即记录。
         */
        preOrder.append(cur).append(" ");

        // 向左延伸
        traverse(lc[cur]);

        /**
         * 2. 中序遍历 (In-order)：左 -> [中] -> 右
         * 当左子树全部处理完毕回溯到当前点时记录。
         */
        inOrder.append(cur).append(" ");

        // 向右延伸
        traverse(rc[cur]);

        /**
         * 3. 后序遍历 (Post-order)：左 -> 右 -> [中]
         * 当左右子树全部处理完毕，即将彻底离开当前点时记录。
         */
        postOrder.append(cur).append(" ");
    }

【十叉树的先序遍历】字典序的第K小数字

Tue, 03 Feb 2026 21:32:47 +0000

求解代码

public int findKthNumber(int n, int k) {
            int cur = 1;// 从字典序第一个数字 1 开始
            k--;// 转换为 0 索引
            while (k > 0) {

                // 计算以cur为根的子树，包含的有效节点数量

                int steps = getSteps(cur, n);

                if (steps <= k) {
                    // 目标不在当前子树，跳过整棵子树，更新k和当前节点
                    k -= steps;
                    cur++;
                } else {
                    // 目标在子树中，进入子节点，k减1（跳过当前节点）
                    cur *= 10;
                    k--;
                }
            }

            return cur;
        }

        // 计算以cur为根节点的子树中，<=n的节点总数
        private int getSteps(int cur, long n) {
            int steps = 0;
            long first = cur; // 当前层起始节点
            long last = cur; // 当前层结束节点

            while (first <= n) {
                // 累加当前层的节点数，防止last超出n
                steps += Math.min(last, n) - first + 1;

                // 进入下一层
                first *= 10;
                last = last * 10 + 9;
            }

            return steps;
        }

小贴士

k-- 是为了将1-based的输入转换为0-based计数
first/last 必须用 long 类型，避免 int 乘法溢出；

【回溯】二叉树的所有路径

Mon, 02 Feb 2026 23:27:38 +0000

求解代码

public List<String> binaryTreePaths(TreeNode root) {
            List<String> ans = new ArrayList<>();
            if (root == null) {
                return ans;
            }
            StringBuilder sb = new StringBuilder();
            backtrack(root, sb, ans);
            return ans;
        }

        private void backtrack(TreeNode root, StringBuilder sb, List<String> ans) {
            if (root == null) {
                return;
            }
            // 记录当前拼接前的长度，用于回溯撤销
            int len = sb.length();

            sb.append(root.val);
            // 到达叶子节点，添加完整路径
            if (root.left == null && root.right == null) {
                ans.add(sb.toString());
            } else {
                sb.append("->");
                backtrack(root.left, sb, ans);
                backtrack(root.right, sb, ans);
            }
            // 回溯撤销，恢复StringBuilder到拼接前的状态
            sb.setLength(len);
        }

新视角-输出二叉树的右视图

Wed, 14 Jan 2026 23:55:54 +0000

求解代码

// 存储最终结果：key = 二叉树的层级（根节点在第0层），value = 该层级【最右侧】的节点值
    private HashMap<Integer, Integer> ans = new HashMap<>();
    // 预处理哈希表：key=中序数组的节点值，value=该值在中序数组的下标
    private HashMap<Integer, Integer> map = new HashMap<>();
    // 前序数组的全局遍历指针：按「根→左→右」的前序规则，依次取当前递归层的根节点，取完自增
    private int level = 0;
    
    public void buildTree(int[] preOrder, int[] inOrder, int left, int right, int i) {
        
        if (left > right) {
            return;
        }
        // 按前序顺序取根节点，通过哈希表拿到根节点在中序数组的下标index
        int index = map.get(preOrder[level++]);
        // 递归构建左子树，中序区间[left, index-1]，子节点层级 = 父层级+1
        buildTree(preOrder, inOrder, left, index - 1, i + 1);
        // 递归构建右子树，中序区间[index+1, right]，子节点层级 = 父层级+1
        buildTree(preOrder, inOrder, index + 1, right, i + 1);
        // 存入当前节点到对应层级，后存的节点会覆盖先存的 → 最终保留该层最右侧节点
        ans.put(i, inOrder[index]);
    }    



    public int[] solve (int[] preOrder, int[] inOrder) {
        for(int i=0;i<inOrder.length;i++){
            map.put(inOrder[i], i);
        }

        buildTree(preOrder,inOrder,0,preOrder.length-1,0);

        int[] temp = new int[ans.size()];

        for(int i=0;i<ans.size();i++){
            temp[i]=ans.get(i);
        }
        return temp;


    }

小贴士

解释一下这行代码ans.put(i, inOrder[index]);可以拿到「每层最右侧」的节点：

因为在递归时，是先递归构建左子树，再递归构建右子树，这个顺序意味着：在同一层级中，「左侧节点」会被先处理，「右侧节点」被后处理。

对于哈希表来说，相同key的put操作，会覆盖原值，在同一层级中，不管有多少个节点，最终只会存最后一次 put 的那个值。

所以，同一层级的右侧节点一定是最后一个被 put 的，所以最终ans.get(i)拿到的，一定是「第 i 层最右侧的节点值」。

前序+中序-重建二叉树

Wed, 14 Jan 2026 22:48:04 +0000

求解代码

public TreeNode reConstructBinaryTree (int[] preOrder, int[] vinOrder) {
        int pre_len = preOrder.length;
        int vin_len = vinOrder.length;

        if (pre_len == 0 || vin_len == 0) {
            return null;
        }

        TreeNode root = new TreeNode(preOrder[0]);
        for (int i = 0; i < vinOrder.length; i++) {
            if (preOrder[0] == vinOrder[i]) {
                // 左子树：前序从[1, i+1)  中序从[0, i)
                root.left = reConstructBinaryTree(Arrays.copyOfRange(preOrder, 1, i + 1),
                                                  Arrays.copyOfRange(vinOrder, 0, i));
                // 右子树：前序从[i+1, pre_len)  中序从[i+1, vin_len)
                root.right = reConstructBinaryTree(Arrays.copyOfRange(preOrder, i + 1,
                                                   preOrder.length), Arrays.copyOfRange(vinOrder, i + 1, vinOrder.length));
                break;
            }

        }
        return root;
    }

小贴士

`1`	`Arrays.copyOfRange(原数组, from, to) → 复制数组的[from, to)区间，返回新数组；`

中序遍历分割数组比较好理解：

中序遍历过程中左子树是从[0,i)，右子树是从[i+1,vin_len)

前序遍历分割数组可能会有点绕，这里解释一下：

当中序遍历到位置i时，可以得知左子树所在的区间是[0,i-1]，长度就是i；

那么回到前序遍历中来，因为同一棵树它的左子树的长度在前序遍历和中序遍历的过程中是相同的，也就是长度是i，那么又因为前序遍历的0位置是根节点，则前序遍历的左子树所在的区间就是[1,i]。

由于Arrays.copyOfRange方法是左闭右开区间，所以前序遍历过程中，左子树是从[1,i+1)，右子树就是从[i+1,pre_len)。

层序遍历-序列化二叉树

Wed, 14 Jan 2026 21:16:56 +0000

求解代码

String Serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        if (root != null) {
            Queue<TreeNode> queue = new LinkedList<>();
            queue.add(root);
            sb.append(root.val + ","); // 先存入根节点值

            while (!queue.isEmpty()) {
                root = queue.poll(); // 取出队首的待处理节点

                // 严格先处理左孩子：有值存值+逗号，无值存# +逗号
                if (root.left != null) {
                    sb.append(root.left.val + ",");
                    queue.add(root.left);
                } else {
                    sb.append("#,");
                }

                // 严格后处理右孩子：有值存值+逗号，无值存# +逗号
                if (root.right != null) {
                    sb.append(root.right.val + ",");
                    queue.add(root.right);
                } else {
                    sb.append("#,");
                }
            }
        }
        return sb.toString();
    }


    TreeNode Deserialize(String str) {
        if (str.equals("")) {
            return null;
        }
        String[] nodes = str.split(","); // 按分隔符拆分出所有节点内容
        int index = 0;
        TreeNode root = generate(nodes[index++]); // 第一个元素是根节点
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll(); // 取出待分配子节点的父节点
            cur.left = generate(nodes[index++]); // 严格先分配左孩子
            cur.right = generate(nodes[index++]); // 严格后分配右孩子

            // 只有非空节点才有子节点，需要入队等待分配子节点
            if (cur.left != null) queue.add(cur.left);
            if (cur.right != null) queue.add(cur.right);
        }
        return root;
    }

    TreeNode generate(String val) {
        return val.equals("#") ? null : new TreeNode(Integer.parseInt(val));
    }

小贴士：

Integer.parseInt () 和 Integer.valueOf () 这俩都是 Java 中把「数字格式的字符串」转为整数的核心静态方法，最核心的区别只有一个： ✅ Integer.parseInt(String s) → 返回 基本数据类型 int ✅ Integer.valueOf(String s) → 返回 包装类对象 Integer

递归-在二叉树中找到两个节点的最近公共祖先

Wed, 14 Jan 2026 19:01:55 +0000

求解代码

前文【非递归】二叉搜索树的最近公共祖先我们利用非递归+迭代的方式求出了二叉搜索树的最近公共祖先，主要还是利用了二叉搜索树左子树所有节点值<根节点值<右子树所有节点值的特性。

但是，普通二叉树的节点值没有这样的规律，没办法通过数值的大小进行位置的判断力。

本文使用递归的方式求普通二叉树的最近公共祖先：

public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
        if (root == null) {
            return -1;
        }
        if (root.val == o1 || root.val == o2) {
            return root.val;
        }



        int left = lowestCommonAncestor(root.left, o1, o2);
        int right = lowestCommonAncestor(root.right, o1, o2);

        if (left == -1) {
            return right;
        }

        if (right == -1) {
            return left;
        }

        return root.val;

    }

非递归-二叉搜索树的最近公共祖先

Wed, 14 Jan 2026 15:06:51 +0000

求解代码

如果根节点的值和p,q的差值相乘是正数，说明这两个差值要么都是正数，要么都是负数，所以p、q肯定位于根节点的同一侧，需要继续往下找；

如果相乘的结果是负数，说明p、q位于根节点的值两侧；

如果相乘为0，说明p，q至少有一个是根节点的值。

public int lowestCommonAncestor (TreeNode root, int p, int q) {
        
        while ((root.val-p)*(root.val-q)>0) {
            root = root.val>p?root.left:root.right;
        }
        return root.val;
    }

从上到下-判断是不是平衡二叉树

Tue, 13 Jan 2026 20:52:09 +0000

求解代码

平衡二叉树的核心判断条件：

当前节点的左右子树高度差小于等于1；
当前节点的左右子树本身也是平衡二叉树；

  public boolean IsBalanced_Solution (TreeNode pRoot) {
       if(pRoot == null){
        return true;
       }

       int left = depth(pRoot.left);
       int right = depth(pRoot.right);

       return Math.abs(left-right)<=1&&IsBalanced_Solution(pRoot.left)&&IsBalanced_Solution(pRoot.right);
}

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

        return Math.max(depth(root.left),depth(root.right))+1;
    }

数组实现双端队列-判断是不是完全二叉树

Tue, 13 Jan 2026 20:23:35 +0000

求解代码

不是完全二叉树主要就两种情况：

1.有右节点无左节点

2.如果是孩子不全的节点，则接下来必须全是叶子节点，否则就不是完全二叉树，对应设置一个leaf变量。

队列双指针：left=队头(出队)，right=队尾(入队)

leaf 变量的含义：

是否已经进入【叶子节点阶段】，也可以理解为后续所有节点都必须是「无孩子的叶子节点」，初始值false表示「还没到这个阶段」。

	public static int MAXN = 101;
	public static TreeNode[] queue = new TreeNode[MAXN];
	public static int left,right;


    public boolean isCompleteTree (TreeNode root) {
        if(root==null){
			return true;
		}

		left=right=0;

		queue[right++]=root;

		boolean leaf = false;
		while (left<right) {
			root = queue[left++];

			if(leaf&&(root.left!=null||root.right!=null)){
				return false;
			}

			if(root.left==null&&root.right!=null){
				return false;
			}

			if(root.left!=null){
				queue[right++]=root.left;
			}

			if (root.right!=null) {
				queue[right++]=root.right;
			}

			if (root.left==null||root.right==null) {
				leaf = true;
			}
		}
		return true;

    }

递归-判断是不是二叉搜索树

Tue, 13 Jan 2026 19:03:28 +0000

求解代码

之所以加上min和max，是因为二叉搜索树需要满足整棵左子树的所有节点都要小于根，整棵右子树的所有节点都要大于根。

    public boolean isValidBST (TreeNode root) {
        return isValidBST(root, null, null);
    }

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

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

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

		return isValidBST(root.left,min,root)&&isValidBST(root.right,root,max);
	}

递归-二叉树的镜像

Tue, 13 Jan 2026 18:00:06 +0000

求解代码

这道题遍历二叉树的每一个节点，然后交换左右子节点就可以了。

1.前序遍历

   public TreeNode Mirror (TreeNode pRoot) {
        if(pRoot==null){
			return null;
		}

		TreeNode temp = pRoot.left;
		pRoot.left = pRoot.right;
		pRoot.right = temp;

		Mirror(pRoot.left);
		Mirror(pRoot.right);

		return pRoot;
    }

2.中序遍历

public TreeNode Mirror (TreeNode pRoot) {
        if(pRoot==null){
			return null;
		}


		Mirror(pRoot.left);

		TreeNode temp = pRoot.left;
		pRoot.left = pRoot.right;
		pRoot.right = temp;



		Mirror(pRoot.left);//注意上面交换过了

		return pRoot;
    }

3.后序遍历

public TreeNode Mirror (TreeNode pRoot) {
        if(pRoot==null){
			return null;
		}

		TreeNode left = Mirror(pRoot.left);
		TreeNode right = Mirror(pRoot.right);

		pRoot.left = right;
		pRoot.right = left;

		return pRoot;
    }

注意⚠️：

这里解释一下中序遍历的第二个递归为什么是Mirror(pRoot.left);而不是Mirror(pRoot.right);?

因为执行完：

1
2
3

		TreeNode temp = pRoot.left;
		pRoot.left = pRoot.right;
		pRoot.right = temp;

这三行代码之后，当前节点的左右指针发生了互换，指向变成了：

1
2

pRoot.left → 原右子树 (R)  
pRoot.right → 原左子树 (L)

要处理的「原右子树 R」，现在的内存地址其实是 pRoot.left，

如果此时写 Mirror(pRoot.right)，实际处理的是「已经翻转完的原左子树 L」，这样就会造成翻转结果错误。

递归-合并二叉树

Mon, 12 Jan 2026 19:42:04 +0000

求解代码

public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
        if(t1==null){
			return t2;
		}

		if(t2==null){
			return t1;
		}

		TreeNode head = new TreeNode(t1.val+t2.val);
		head.left = mergeTrees(t1.left, t2.left);
		head.right = mergeTrees(t1.right, t2.right);

		return head;

    }

递归-对称的二叉树

Mon, 12 Jan 2026 19:29:57 +0000

求解代码

	boolean recursion(TreeNode root1, TreeNode root2){
		if(root1==null&&root2==null){
			return true;
		}

		if(root1==null||root2==null||root1.val!=root2.val){
			return false;
		}

		return recursion(root1.left, root2.right)&&recursion(root1.right, root2.left);
	}
	public boolean isSymmetrical (TreeNode pRoot) {
        return recursion(pRoot, pRoot);
    }

这里说明一下为什么要调用recursion(pRoot, pRoot);把根节点传两次：

本质上就是把判断一棵树是否对称的问题转化为判断两棵树是否互为镜像的问题。

第一颗树的遍历规则是：正常的根➡️左➡️右；

第二棵树的遍历规则是：镜像的根➡️右➡️左；

只要这两个遍历结果完全匹配，那么原树就是对称的。

递归-二叉搜索树与双向链表

Mon, 12 Jan 2026 18:57:53 +0000

求解代码

public TreeNode head = null;//双向链表的头节点
public TreeNode cur = null;//双向链表的尾节点游标

public TreeNode Convert(TreeNode pRootOfTree) {
if(pRootOfTree==null){
return null;
}

Convert(pRootOfTree.left);

if(cur == null){
head = pRootOfTree;
cur = pRootOfTree;
}else{
cur.right = pRootOfTree;
pRootOfTree.left = cur;
cur = pRootOfTree;
}

Convert(pRootOfTree.right);
return head;
}

说明：

核心就在于其中的if/else语句。

1
2

if(cur为空) → 初始化链表，头和尾都是第一个节点；
else → 把当前节点拼到链表尾部，完成双向绑定，然后移动尾指针。

递归-二叉树中和为某一值的路径-一

Mon, 12 Jan 2026 17:36:11 +0000

求解代码

检查遍历到的是否为叶子节点，并且当前的sum值等于节点值，如果是，说明恰好可以找到。

public boolean hasPathSum (TreeNode root, int sum) {
        if(root==null){
			return false;
		}

		if(root.left==null&&root.right==null&&sum-root.val==0){
			return true;
		}

		return hasPathSum(root.left, sum-root.val)||hasPathSum(root.right, sum-root.val);
    }

递归-二叉树的最大深度

Mon, 12 Jan 2026 17:15:19 +0000

求解代码

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

		return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
    }

队列-按之字形顺序打印二叉树

Sun, 11 Jan 2026 19:32:36 +0000

求解代码

在【队列】求二叉树的层序遍历的基础上增加一个flag区分奇偶性就行。

public ArrayList<ArrayList<Integer>> Print (TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> ans = new ArrayList<>();

		if(pRoot==null){
			return ans;
		}
		Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
		queue.add(pRoot);

		boolean flag = true;

		while(!queue.isEmpty()){
			ArrayList<Integer> list = new ArrayList<>();

			int n = queue.size();

			flag = !flag;

			for(int i=0;i<n;i++){
				TreeNode cur = queue.poll();
				list.add(cur.val);

				if (cur.left!=null) {
					queue.add(cur.left);
				}
				
				if(cur.right!=null){
					queue.add(cur.right);
				}
			}

			if(flag){
				Collections.reverse(list);
			}
			ans.add(list);
		}

		return ans;
    }

队列-求二叉树的层序遍历

Sun, 11 Jan 2026 19:12:25 +0000

求解代码

构建一个辅助队列queue，让root首先进入队列。

public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        ArrayList<ArrayList<Integer>> ans = new ArrayList<>();

		if(root==null){
			return ans;
		}
		Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
		queue.add(root);

		while(!queue.isEmpty()){
			ArrayList<Integer> list = new ArrayList<>();

			int n = queue.size();

			for(int i=0;i<n;i++){
				TreeNode cur = queue.poll();
				list.add(cur.val);

				if (cur.left!=null) {
					queue.add(cur.left);
				}
				
				if(cur.right!=null){
					queue.add(cur.right);
				}
			}
			ans.add(list);
		}

		return ans;
    }

递归-二叉树的后序遍历

Sun, 11 Jan 2026 17:57:22 +0000

求解代码

public void postorder(List<Integer> list, TreeNode root){
		if(root==null){
			return;
		}

		postorder(list, root.left);
		postorder(list, root.right);
		
		list.add(root.val);
	}
    public int[] postorderTraversal (TreeNode root) {
        
		List<Integer> list = new ArrayList<>();
		postorder(list, root);

		int[] ans = new int[list.size()];

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

		return ans;
    }

说明：

和前文【递归】二叉树的前序遍历的区别就是把list.add(root.val); 这行代码放到了两个递归之后。

总结一下：

前序遍历，list.add(root.val); 这行代码放到两个递归之前。
中序遍历，list.add(root.val); 这行代码放到两个递归之间。
后序遍历，list.add(root.val); 这行代码放到两个递归之后。

二叉树递归遍历的灵魂就在于list.add(root.val); 的位置决定遍历的方式，而递归的逻辑完全不变。

递归-二叉树的中序遍历

Sun, 11 Jan 2026 17:46:53 +0000

public void inorder(List<Integer> list, TreeNode root){
		if(root==null){
			return;
		}

		inorder(list, root.left);
		list.add(root.val);
		inorder(list, root.right);
	}
    public int[] inorderTraversal (TreeNode root) {
        
		List<Integer> list = new ArrayList<>();
		inorder(list, root);

		int[] ans = new int[list.size()];

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

		return ans;
    }

说明：

和前文【递归】二叉树的前序遍历的区别就是把list.add(root.val); 这行代码放到了两个递归之间。

二叉树递归遍历的灵魂就在于list.add(root.val); 的位置决定遍历的方式，而递归的逻辑完全不变。

递归-二叉树的前序遍历

Sun, 11 Jan 2026 17:36:19 +0000

求解代码

public void preorder(List<Integer> list, TreeNode root){
		if(root==null){
			return;
		}

		list.add(root.val);

		preorder(list, root.left);
		preorder(list, root.right);
	}
    public int[] preorderTraversal (TreeNode root) {
        
		List<Integer> list = new ArrayList<>();
		preorder(list, root);

		int[] ans = new int[list.size()];

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

		return ans;
    }

为什么你的滑动窗口总是写不对

Fri, 12 Dec 2025 21:00:40 +0000

求解思路

这道题直接求解很困难，因为我们既要保证每种字符出现次数≥k，又要让子串尽可能长，这两个条件相互制约难以平衡。

但如果我们换个角度，先固定子串中必须恰好包含require种不同的字符，然后在这个约束下用滑动窗口找最长子串，问题就变得简单了。我们从require=1开始枚举到require=26（英文字母最多26种），对于每个require值，用双指针维护一个窗口，右指针不断扩展收集字符，当窗口中的字符种类数超过require时，左指针就收缩窗口把多余的字符吐出去，在满足"种类数等于require且每种字符次数都≥k"这个条件时更新答案。

代码实现

public static int longestSubstring(String str, int k) {
    char[] s = str.toCharArray();
    int n = s.length;
    int[] cnts = new int[256];
    int ans = 0;
    
    // 枚举子串中字符的种类数
    for (int require = 1; require <= 26; require++) {
        Arrays.fill(cnts, 0);
        // collect: 窗口中字符的种类数
        // satisfy: 窗口中出现次数≥k的字符种类数
        for (int l = 0, r = 0, collect = 0, satisfy = 0; r < n; r++) {
            // 右指针扩展窗口
            cnts[s[r]]++;
            if (cnts[s[r]] == 1) {
                collect++;  // 新增一种字符
            }
            if (cnts[s[r]] == k) {
                satisfy++;  // 该字符达标
            }
            
            // 左指针收缩窗口，保证种类数不超过require
            while (collect > require) {
                if (cnts[s[l]] == 1) {
                    collect--;
                }
                if (cnts[s[l]] == k) {
                    satisfy--;
                }
                cnts[s[l++]]--;
            }
            
            // 当所有字符都达标时更新答案
            if (satisfy == require) {
                ans = Math.max(ans, r - l + 1);
            }
        }
    }
    return ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

一道面试高频题-最小覆盖子串的O(n)解法

Mon, 08 Dec 2025 22:09:20 +0000

求解思路

这道题我们可以把问题想象成"欠债还债"的过程:

一开始我们欠目标字符串 tar 中所有字符的债,然后用一个窗口在源字符串 str 上滑动,不断"还债"。

具体来说,我们用右指针 r 不断向右扩展窗口来收集字符还债,当债务全部还清时(也就是窗口已经包含了 tar 的所有字符),我们就尝试收缩左边界 l 来让这个窗口尽可能小,把那些"多给的"字符收回来。

在这个过程中,我们记录下遇到的最小窗口的位置和长度,最后返回这个最小窗口对应的子串就是答案。

举个栗子

假设 str = "ADOBECODEBANC", tar = "ABC":

右指针扩展到 ADOBEC 时,debt 首次归零
左指针收缩,去掉 ADO,得到 BANC
继续右移,在 CODEBA 时再次覆盖
收缩后得到 BA,但不满足(缺C)
最终确定最小窗口是 BANC

代码实现

public static String minWindow(String str, String tar) {
    if (str.length() < tar.length()) {
        return "";
    }
    char[] s = str.toCharArray();
    char[] t = tar.toCharArray();
    int[] cnts = new int[256];
    
    // 初始化欠债表:tar中的字符都标记为负数(欠债)
    for (char cha : t) {
        cnts[cha]--;
    }
    
    int len = Integer.MAX_VALUE;  // 最小覆盖子串的长度
    int start = 0;                // 最小覆盖子串的起始位置
    
    for (int l = 0, r = 0, debt = t.length; r < s.length; r++) {
        // 当前字符s[r]进入窗口,还债
        if (cnts[s[r]]++ < 0) {
            debt--;  // 只有真正需要的字符才能减少债务
        }
        
        if (debt == 0) {
            // 债务还清,找到了一个覆盖子串
            // 尝试收缩左边界,去掉多余字符
            while (cnts[s[l]] > 0) {
                cnts[s[l++]]--;
            }
            
            // 更新最小窗口
            if (r - l + 1 < len) {
                len = r - l + 1;
                start = l;
            }
        }
    }
    
    return len == Integer.MAX_VALUE ? "" : str.substring(start, start + len);
}

如果觉得有帮助，欢迎点赞、关注、转发~

无重复字符的最长子串

Sun, 07 Dec 2025 21:10:22 +0000

解题思路

这道题我们可以把问题想象成这样：

用两个指针l和r圈定一个窗口，这个窗口内始终保持没有重复字符，然后让这个窗口在字符串上不断滑动。

具体来说，右指针r不断向右扩展窗口，每次遇到一个新字符时，先检查这个字符之前是否在窗口内出现过，如果出现过，就把左指针l移动到那个重复字符的下一个位置，这样就保证了窗口内永远没有重复字符。

在这个过程中，我们持续记录窗口的最大长度，最后得到的就是答案。

举个栗子

输入: “abcabcbb”

r=0时,‘a’首次出现,窗口[a],长度=1
r=1时,‘b’首次出现,窗口[ab],长度=2
r=2时,‘c’首次出现,窗口[abc],长度=3
r=3时,‘a’重复,l移到位置1,窗口[bca],长度=3
r=4时,‘b’重复,l移到位置2,窗口[cab],长度=3
r=5时,‘c’重复,l移到位置3,窗口[abc],长度=3
r=6时,‘b’重复,l移到位置5,窗口[cb],长度=2
r=7时,‘b’重复,l移到位置7,窗口[b],长度=1

输出: 3 (最长子串为"abc")

代码实现

public static int lengthOfLongestSubstring(String str) {
    char[] s = str.toCharArray();
    int n = s.length;
    // 记录每个字符上次出现的位置
    int[] last = new int[256];
    // 初始化所有字符都没有出现过
    Arrays.fill(last, -1);
    // 记录最长子串长度
    int ans = 0;
    
    for (int l = 0, r = 0; r < n; r++) {
        // 如果当前字符之前出现过,移动左指针到重复位置的下一位
        l = Math.max(l, last[s[r]] + 1);
        // 更新最长长度
        ans = Math.max(ans, r - l + 1);
        // 记录当前字符的位置
        last[s[r]] = r;
    }
    return ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

最长元音偶数子串问题

Sat, 29 Nov 2025 20:55:31 +0000

求解思路

这道题我们不需要记录每个元音的具体出现次数，只需要关心它们的奇偶性。

用一个5位的二进制数表示5个元音的奇偶状态，第0-4位分别对应a、e、i、o、u，0表示偶数次，1表示奇数次。

遍历字符串时，遇到元音就通过异或操作翻转对应位，这样当前状态就表示从开头到当前位置各元音的奇偶性。

如果某个状态之前出现过，说明这两个位置之间的子串中所有元音都出现了偶数次（因为奇偶性相同），此时计算长度并更新答案。

用哈希表记录每个状态最早出现的位置，这样就能找到最长的满足条件的子串。

代码实现

public static int findTheLongestSubstring(String s) {
    int n = s.length();
    // 状态数组，32种可能的奇偶组合(2^5)
    int[] map = new int[32];
    Arrays.fill(map, -2);  // -2表示未出现
    map[0] = -1;  // 初始状态（全偶数）在-1位置
    
    int ans = 0;
    for (int i = 0, status = 0, m; i < n; i++) {
        m = move(s.charAt(i));
        if (m != -1) {
            // 翻转对应元音的奇偶位
            status ^= 1 << m;
        }
        
        if (map[status] != -2) {
            // 相同状态之前出现过，计算子串长度
            ans = Math.max(ans, i - map[status]);
        } else {
            // 记录该状态首次出现位置
            map[status] = i;
        }
    }
    return ans;
}

public static int move(char cha) {
    switch (cha) {
        case 'a': return 0;
        case 'e': return 1;
        case 'i': return 2;
        case 'o': return 3;
        case 'u': return 4;
        default: return -1;
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

单词搜索-II-前缀树+DFS优化

Sat, 22 Nov 2025 22:17:00 +0000

求解思路

首先将所有目标单词构建成一棵前缀树，然后遍历网格中的每个位置作为起点进行DFS搜索，在搜索过程中同时在前缀树上行走，如果当前路径在前缀树中不存在则立即剪枝返回，这样可以一次DFS同时匹配多个单词。

使用pass数组记录每个前缀树节点下还有多少个待匹配的单词，当找到一个单词后，回溯路径上的所有pass值都减去对应数量，如果某个节点的pass变为0说明该分支下已无待匹配单词可以提前终止。

为了避免重复，找到的单词会立即从end数组中删除，并且搜索过程中通过临时标记访问过的格子来防止走回头路。

代码实现

public static final int MAXN = 10001;
    public static int[][] tree = new int[MAXN][26];
    public static int[] pass = new int[MAXN];
    public static String[] end = new String[MAXN];
    public static int cnt;
    
    public static List<String> findWords(char[][] board, String[] words) {
        build(words);
        List<String> ans = new ArrayList<>();
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                dfs(board, i, j, 1, ans);
            }
        }
        clear();
        return ans;
    }
    
    public static int dfs(char[][] board, int i, int j, int t, List<String> ans) {
    // 边界检查：越界或者已访问过（board[i][j]==0表示已访问）
    if (i < 0 || i == board.length || j < 0 || j == board[0].length || board[i][j] == 0) {
        return 0;
    }
    
    char tmp = board[i][j];  // 保存当前字符，回溯时要恢复
    int road = tmp - 'a';     // 字符转换为路径编号
    t = tree[t][road];        // 在前缀树上走一步
    
    // 剪枝：如果前缀树这个节点下没有待匹配的单词了，直接返回
    if (pass[t] == 0) {
        return 0;
    }
    
    int fix = 0;  // 记录从这个位置开始找到了几个单词
    
    // 如果当前节点是某个单词的结尾，收集这个单词
    if (end[t] != null) {
        fix++;
        ans.add(end[t]);
        end[t] = null;  // 置空，避免重复收集
    }
    
    // 标记当前位置已访问（防止走回头路）
    board[i][j] = 0;
    
    // 向四个方向继续搜索
    fix += dfs(board, i - 1, j, t, ans);  // 上
    fix += dfs(board, i + 1, j, t, ans);  // 下
    fix += dfs(board, i, j - 1, t, ans);  // 左
    fix += dfs(board, i, j + 1, t, ans);  // 右
    
    // 回溯：恢复现场
    pass[t] -= fix;      // 更新这个节点下剩余的单词数
    board[i][j] = tmp;   // 恢复字符，供其他路径使用
    
    return fix;
}
    
    public static void build(String[] words) {
    cnt = 1;  // 节点编号从1开始，1是根节点
    for (String word : words) {
        int cur = 1;  // 从根节点开始
        pass[cur]++;  // 根节点下的单词数+1
        
        for (int i = 0; i < word.length(); i++) {
            int path = word.charAt(i) - 'a';  // 当前字符对应的路径编号
            if (tree[cur][path] == 0) {  // 如果这条路不存在
                tree[cur][path] = ++cnt;  // 创建新节点
            }
            cur = tree[cur][path];  // 走到下一个节点
            pass[cur]++;  // 这个节点下的单词数+1
        }
        end[cur] = word;  // 在单词结尾节点存储完整单词
    }
}
    
    public static void clear() {
        for (int i = 1; i <= cnt; i++) {
            Arrays.fill(tree[i], 0);
            pass[i] = 0;
            end[i] = null;
        }
    }

如果觉得有帮助，欢迎点赞、关注、转发~

数组中两个数的最大异或值

Fri, 21 Nov 2025 20:57:01 +0000

求解思路

要让异或结果尽可能大，就要让高位尽可能出现1。

我们可以从最高位开始贪心，每一位都尝试让结果为1。

具体来说就是，先找到数组中最大值确定需要考虑的最高位，然后有2种解法：

第1种是用前缀树存储所有数字的二进制表示，查询时对于每个数字从高位到低位贪心地选择相反的路径（即当前位是0就找1，是1就找0），这样能保证异或结果尽可能大；

第2种是用哈希表，从高位到低位逐位确定答案，每次尝试在当前答案基础上让下一位为1，通过哈希表快速判断是否存在两个数能达成这个目标。

方法1：前缀树解法

public static int findMaximumXOR(int[] nums) {
    build(nums);
    int ans = 0;
    for (int num : nums) {
        ans = Math.max(ans, maxXor(num));
    }
    clear();
    return ans;
}

public static int MAXN = 3000001;
public static int[][] tree = new int[MAXN][2];
public static int cnt;
public static int high;

public static void build(int[] nums) {
    cnt = 1;
    int max = Integer.MIN_VALUE;
    for (int num : nums) {
        max = Math.max(num, max);
    }
    // 计算最高有效位，忽略前导零
    high = 31 - Integer.numberOfLeadingZeros(max);
    for (int num : nums) {
        insert(num);
    }
}

public static void insert(int num) {
    int cur = 1;
    for (int i = high, path; i >= 0; i--) {
        path = (num >> i) & 1;
        if (tree[cur][path] == 0) {
            tree[cur][path] = ++cnt;
        }
        cur = tree[cur][path];
    }
}

public static int maxXor(int num) {
    int ans = 0;
    int cur = 1;
    for (int i = high, status, want; i >= 0; i--) {
        status = (num >> i) & 1;
        want = status ^ 1;  // 期望遇到相反的位
        if (tree[cur][want] == 0) {
            want ^= 1;  // 如果不存在则走相同的位
        }
        ans |= (status ^ want) << i;
        cur = tree[cur][want];
    }
    return ans;
}

public static void clear() {
    for (int i = 1; i <= cnt; i++) {
        tree[i][0] = tree[i][1] = 0;
    }
}

方法2：哈希表解法

public int findMaximumXOR(int[] nums) {
    int max = Integer.MIN_VALUE;
    for (int num : nums) {
        max = Math.max(num, max);
    }
    int ans = 0;
    HashSet<Integer> set = new HashSet<>();
    for (int i = 31 - Integer.numberOfLeadingZeros(max); i >= 0; i--) {
        int better = ans | (1 << i);  // 尝试让第i位为1
        set.clear();
        for (int num : nums) {
            num = (num >> i) << i;  // 保留高位，低位清零
            set.add(num);
            // 如果存在 better ^ num，说明可以达成better
            if (set.contains(better ^ num)) {
                ans = better;
                break;
            }
        }
    }
    return ans;
}

利用差分数组与前缀树高效统计一致密钥

Thu, 20 Nov 2025 21:15:45 +0000

求解思路

首先，我们需要提取每个序列的特征，即计算相邻元素的差分数组。

为了方便存储和查找，将这些差分数值转换为字符串格式，并在每个数值后添加特殊分隔符（如 #）以区分多位数（防止 1, 2 和 12 混淆），同时处理负号。

接着，构建一个静态数组实现的字典树（Trie），将 a 数组中所有序列生成的差分字符串插入树中，利用 Trie 节点的 pass 计数功能记录每种差分模式出现的次数。

最后，遍历查询数组 b，以同样的方式生成差分字符串并在 Trie 中进行检索，检索路径终点的 pass 值即为该模式在 a 中出现的总次数。

完整实现代码

import java.util.Arrays;

public class Solution {

    // 统计 b 中每个序列在 a 中有多少个“一致”的序列
    public static int[] countConsistentKeys(int[][] b, int[][] a) {
        // 初始化静态空间
        build();
        StringBuilder builder = new StringBuilder();
        
        // 将每个序列转换为差分字符串并在 Trie 中注册
        for (int[] nums : a) {
            builder.setLength(0);
            // 计算相邻元素的差值
            for (int i = 1; i < nums.length; i++) {
                // 使用 # 作为分隔符，防止数字粘连（如 1,2 变成 12）
                builder.append(String.valueOf(nums[i] - nums[i - 1]) + "#");
            }
            insert(builder.toString());
        }
        
        int[] ans = new int[b.length];
        
        // 生成差分字符串并在 Trie 中查询计数
        for (int i = 0; i < b.length; i++) {
            builder.setLength(0);
            int[] nums = b[i];
            for (int j = 1; j < nums.length; j++) {
                builder.append(String.valueOf(nums[j] - nums[j - 1]) + "#");
            }
            // count 方法返回该路径（模式）被经过的次数
            ans[i] = count(builder.toString());
        }
        
        // 清理静态内存，防止污染下一次调用
        clear();
        return ans;
    }

    // 根据题目数据范围预估的最大节点数
    public static int MAXN = 2000001;

    // tree[i][j] 表示节点 i 经过字符 j 指向的下一个节点索引
    // 字符集大小为 12：包含 0-9 十个数字，以及 '#' 和 '-'
    public static int[][] tree = new int[MAXN][12];

    // pass[i] 记录经过节点 i 的字符串数量
    public static int[] pass = new int[MAXN];

    // 当前使用的节点计数器
    public static int cnt;

    // 初始化 Trie
    public static void build() {
        cnt = 1; // 1 号点作为根节点
    }

    // 将字符映射到 tree 数组的列索引 0~11
    public static int path(char cha) {
        if (cha == '#') {
            return 10; // '#' 映射为 10
        } else if (cha == '-') {
            return 11; // '-' 映射为 11
        } else {
            return cha - '0'; // '0'~'9' 映射为 0~9
        }
    }

    // 插入字符串到 Trie
    public static void insert(String word) {
        int cur = 1; // 从根节点开始
        pass[cur]++; // 根节点计数+1
        for (int i = 0, path; i < word.length(); i++) {
            path = path(word.charAt(i));
            // 如果当前路径不存在，分配新节点
            if (tree[cur][path] == 0) {
                tree[cur][path] = ++cnt;
            }
            cur = tree[cur][path];
            pass[cur]++; // 沿途节点计数+1
        }
    }

    // 利用 pass 数组，返回完全匹配该前缀（即整个差分串）的次数
    public static int count(String pre) {
        int cur = 1;
        for (int i = 0, path; i < pre.length(); i++) {
            path = path(pre.charAt(i));
            // 如果路径断了，说明该模式从未出现过
            if (tree[cur][path] == 0) {
                return 0;
            }
            cur = tree[cur][path];
        }
        // 返回终点的 pass 值，即为该模式的总出现次数
        return pass[cur];
    }

    // 清空静态数组，服务于多测试用例场景
    public static void clear() {
        for (int i = 1; i <= cnt; i++) {
            Arrays.fill(tree[i], 0);
            pass[i] = 0;
        }
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

字典树的实现

Wed, 19 Nov 2025 20:51:03 +0000

求解思路

使用二维数组tree来存储树的边关系,其中tree[i][j]表示节点i通过字符j能到达的子节点编号。

同时维护2个辅助数组:

end数组记录以某节点结尾的完整单词数量,

pass数组记录经过某节点的字符串总数。

插入操作时沿着字符路径向下走,不存在的节点就创建新节点,同时更新pass和end计数。

查询操作只需沿路径查找,返回对应的end值即可判断单词是否存在。

前缀统计则返回最后一个字符对应节点的pass值。

删除操作需要先确认单词存在,然后沿路径将pass值减1,如果某个节点的pass减到0说明没有字符串再经过它,可以直接删除后续路径提前返回,最后将end值减1。

完整代码实现


	public static int MAXN = 150001;

	// tree[i][j]: 节点i通过字符j('a'+j)能到达的子节点编号
	public static int[][] tree = new int[MAXN][26];

	// end[i]: 以节点i结尾的完整单词数量
	public static int[] end = new int[MAXN];

	// pass[i]: 有多少个字符串经过节点i(包括以i结尾的)
	public static int[] pass = new int[MAXN];

	// cnt: 当前已使用的节点编号,从1开始(0表示空)
	public static int cnt;

	// 初始化Trie树,cnt=1表示根节点编号为1
	public static void build() {
		cnt = 1;
	}

	// 插入一个字符串
	public static void insert(String word) {
		int cur = 1; // 从根节点开始
		pass[cur]++; // 根节点的pass值加1

		for (int i = 0, path; i < word.length(); i++) {
			path = word.charAt(i) - 'a'; // 计算字符对应的路径索引(0-25)

			if (tree[cur][path] == 0) {
				// 如果该路径不存在,创建新节点
				tree[cur][path] = ++cnt;
			}

			cur = tree[cur][path]; // 移动到子节点
			pass[cur]++; // 子节点的pass值加1
		}

		end[cur]++; // 标记该节点是一个单词的结尾
	}

	// 查询字符串是否存在,返回该字符串的出现次数
	public static int search(String word) {
		int cur = 1; // 从根节点开始

		for (int i = 0, path; i < word.length(); i++) {
			path = word.charAt(i) - 'a';

			if (tree[cur][path] == 0) {
				// 路径不存在,说明该字符串不在树中
				return 0;
			}

			cur = tree[cur][path]; // 移动到子节点
		}

		return end[cur]; // 返回以该节点结尾的单词数量
	}

	// 统计有多少个字符串以pre作为前缀
	public static int prefixNumber(String pre) {
		int cur = 1; // 从根节点开始

		for (int i = 0, path; i < pre.length(); i++) {
			path = pre.charAt(i) - 'a';

			if (tree[cur][path] == 0) {
				// 前缀不存在
				return 0;
			}

			cur = tree[cur][path]; // 移动到子节点
		}

		return pass[cur]; // 返回经过该节点的字符串总数
	}

	// 删除一个字符串
	public static void delete(String word) {
		if (search(word) > 0) { // 只有当字符串存在时才删除
			int cur = 1;
			pass[cur]--; // 根节点的pass值减1

			for (int i = 0, path; i < word.length(); i++) {
				path = word.charAt(i) - 'a';

				// 先将子节点的pass值减1,再判断是否为0
				if (--pass[tree[cur][path]] == 0) {
					// 如果子节点的pass变为0,说明没有其他字符串经过
					// 可以直接删除这条路径,后续节点也不需要处理了
					tree[cur][path] = 0;
					return;
				}

				cur = tree[cur][path]; // 移动到子节点
			}

			end[cur]--; // 该节点作为结尾的单词数减1
		}
	}

	// 清空Trie树,为下一组测试数据做准备
	public static void clear() {
		for (int i = 1; i <= cnt; i++) {
			Arrays.fill(tree[i], 0); // 清空所有边
			end[i] = 0; // 清空结尾标记
			pass[i] = 0; // 清空经过计数
		}
	}

	public static int m, op;
	public static String[] splits;

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		String line = null;

		// 处理多组测试数据
		while ((line = in.readLine()) != null) {
			build(); // 初始化Trie树
			m = Integer.valueOf(line); // 读取操作数量

			for (int i = 1; i <= m; i++) {
				splits = in.readLine().split(" ");
				op = Integer.valueOf(splits[0]); // 操作类型

				if (op == 1) {
					// 操作1: 插入字符串
					insert(splits[1]);
				} else if (op == 2) {
					// 操作2: 删除字符串
					delete(splits[1]);
				} else if (op == 3) {
					// 操作3: 查询字符串是否存在
					out.println(search(splits[1]) > 0 ? "YES" : "NO");
				} else if (op == 4) {
					// 操作4: 统计前缀数量
					out.println(prefixNumber(splits[1]));
				}
			}

			clear(); // 清空数据结构,为下一组数据做准备
		}

		out.flush();
		in.close();
		out.close();
	}

如果觉得有帮助，欢迎点赞、关注、转发~

化学式字符串解析-一道考验递归功底的经典题

Sun, 16 Nov 2025 20:19:49 +0000

求解思路

采用递归 + TreeMap 的方案：

用递归处理从当前位置到右括号或字符串末尾的内容，遇到大写字母或左括号时，将之前的内容结算到总表中；而TreeMap能够自动保证字典序，便于最终输出。

完整代码实现

public class Solution {
    // 全局变量，记录递归处理到的位置
    public static int where;

    public static String countOfAtoms(String str) {
        where = 0;
        // 递归解析整个字符串
        TreeMap<String, Integer> map = f(str.toCharArray(), 0);
        
        // 构建输出结果
        StringBuilder ans = new StringBuilder();
        for (String key : map.keySet()) {
            ans.append(key);
            int cnt = map.get(key);
            if (cnt > 1) {  // 数量为1时不输出数字
                ans.append(cnt);
            }
        }
        return ans.toString();
    }

    public static TreeMap<String, Integer> f(char[] s, int i) {
        TreeMap<String, Integer> ans = new TreeMap<>();  // 当前层级的总表
        StringBuilder name = new StringBuilder();         // 当前正在收集的原子名称
        TreeMap<String, Integer> pre = null;              // 上一个括号的统计结果
        int cnt = 0;                                      // 当前收集的倍数
        
        while (i < s.length && s[i] != ')') {
            // 遇到大写字母或左括号：触发结算
            if (s[i] >= 'A' && s[i] <= 'Z' || s[i] == '(') {
                fill(ans, name, pre, cnt);  // 将之前的内容加入总表
                // 重置状态
                name.setLength(0);
                pre = null;
                cnt = 0;
                
                if (s[i] >= 'A' && s[i] <= 'Z') {
                    // 收集新的原子名称（以大写字母开头）
                    name.append(s[i++]);
                } else {
                    // 遇到左括号：递归处理括号内容
                    pre = f(s, i + 1);
                    i = where + 1;  // 跳过递归处理过的部分
                }
            } 
            // 小写字母：追加到原子名称
            else if (s[i] >= 'a' && s[i] <= 'z') {
                name.append(s[i++]);
            } 
            // 数字：累加倍数
            else {
                cnt = cnt * 10 + s[i++] - '0';
            }
        }
        
        // 处理最后一部分内容
        fill(ans, name, pre, cnt);
        where = i;  // 更新全局位置，告知上层递归处理到哪里
        return ans;
    }

    public static void fill(TreeMap<String, Integer> ans, 
                           StringBuilder name, 
                           TreeMap<String, Integer> pre, 
                           int cnt) {
        if (name.length() > 0 || pre != null) {
            cnt = cnt == 0 ? 1 : cnt;  // 没有数字默认为1
            
            if (name.length() > 0) {
                // 处理单个原子：如 H2 中的 H
                String key = name.toString();
                ans.put(key, ans.getOrDefault(key, 0) + cnt);
            } else {
                // 处理括号结果：如 (OH)2 中的 OH 表
                for (String key : pre.keySet()) {
                    ans.put(key, ans.getOrDefault(key, 0) + pre.get(key) * cnt);
                }
            }
        }
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

树形DP解决打家劫舍问题

Mon, 10 Nov 2025 20:15:19 +0000

今天来看一个经典的树形动态规划问题——打家劫舍III。

核心思路

定义两个状态:

yes: 偷当前节点时,以该节点为根的子树能获得的最大收益
no: 不偷当前节点时,以该节点为根的子树能获得的最大收益

通过递归遍历树,在回溯过程中计算每个节点的最优解。

代码实现

public static int rob(TreeNode root){
		f(root);
		return Math.max(yes,no);
	}

	// 全局变量,完成了X子树的遍历,返回之后
	// yes变成,X子树在偷头节点的情况下,最大的收益
	public static int yes;

	// 全局变量,完成了X子树的遍历,返回之后
	// no变成,X子树在不偷头节点的情况下,最大的收益
	public static int no;
	public static void f(TreeNode root){
		if(root==null){
			yes = 0;
			no =0;// 边界条件
		}else{
			int y = root.val;  // 偷当前节点的收益,先加上节点值
			int n = 0;         // 不偷当前节点的收益

			f(root.left);      // 递归处理左子树
			y += no;           // 如果偷当前节点,只能累加左子树"不偷根"的收益
			n += Math.max(yes, no);  // 如果不偷当前节点,左子树可以自由选择

			f(root.right);     // 递归处理右子树
			y += no;           // 同样,偷当前节点只能累加右子树"不偷根"的收益
			n += Math.max(yes, no);  // 不偷当前节点,右子树自由选择
			yes = y;
			no = n;//更新全局状态
		}
	}

如果觉得有帮助，欢迎点赞、关注、转发~

二叉搜索树的区间修剪算法

Sun, 09 Nov 2025 19:00:46 +0000

核心思想

利用BST的关键特性：左子树所有节点的值都小于根节点，右子树所有节点的值都大于根节点。

代码实现

public static TreeNode trimBST(TreeNode cur, int low, int high){
    // 递归终止条件：遇到空节点直接返回
    if(cur == null){
        return null;
    }
    
    // 情况1：当前节点太小，答案一定在右子树
    if(cur.val < low){
        return trimBST(cur.right, low, high);
    }
    
    // 情况2：当前节点太大，答案一定在左子树
    if(cur.val > high){
        return trimBST(cur.left, low, high);
    }
    
    // 情况3：当前节点在范围内，保留它，并递归修剪左右子树
    cur.left = trimBST(cur.left, low, high);
    cur.right = trimBST(cur.right, low, high);
    
    return cur;
}

如果觉得有帮助，欢迎点赞、关注、转发~

2种方式验证二叉搜索树

Sat, 08 Nov 2025 20:14:13 +0000

解法1：中序遍历 + 单调性检查

二叉搜索树有一个重要性质：中序遍历的结果必然是严格递增的序列。

利用这个性质，在中序遍历过程中，用一个 pre 指针记录前一个访问的节点，每次访问新节点时检查是否满足 pre.val < cur.val。

代码实现

public static int MAXN = 10001;
public static TreeNode[] stack = new TreeNode[MAXN];
public static int r;

public static boolean isValidBST(TreeNode head) {
    if (head == null) {
        return true;
    }
    TreeNode pre = null;
    r = 0;
    
    // 手写栈实现中序遍历
    while (r > 0 || head != null) {
        if (head != null) {
            // 左子树未处理完，继续向左并入栈
            stack[r++] = head;
            head = head.left;
        } else {
            // 左子树已处理完，弹出当前节点
            head = stack[--r];
            
            // 检查单调性：前一个节点的值必须小于当前节点
            if (pre != null && pre.val >= head.val) {
                return false;
            }
            
            pre = head;
            head = head.right;
        }
    }
    return true;
}

解法2：递归 + 区间验证

对于BST，不仅要比较父子节点，还要保证整棵子树的值范围合法。

因此，需要在递归过程中收集每棵子树的最小值和最大值。

代码实现

public static long min, max;

public static boolean isValidBST(TreeNode head) {
    if (head == null) {
        min = Long.MAX_VALUE;
        max = Long.MIN_VALUE;
        return true;
    }
    
    // 递归处理左子树
    boolean lok = isValidBST(head.left);
    long lmin = min;
    long lmax = max;
    
    // 递归处理右子树
    boolean rok = isValidBST(head.right);
    long rmin = min;
    long rmax = max;
    
    // 更新当前子树的最小值和最大值
    min = Math.min(Math.min(lmin, rmin), head.val);
    max = Math.max(Math.max(lmax, rmax), head.val);
    
    // 验证BST性质：
    // 1. 左右子树各自是BST
    // 2. 左子树最大值 < 当前节点 < 右子树最小值
    return lok && rok && lmax < head.val && head.val < rmin;
}

如果觉得有帮助，欢迎点赞、关注、转发~

判断平衡二叉树

Fri, 07 Nov 2025 20:35:52 +0000

所谓平衡二叉树，就是任意节点的左右子树高度差不超过1。

话不多说，看几个例子帮助理解:

✅ 平衡的树:

每个节点的左右子树高度差都 ≤ 1

❌ 不平衡的树:

节点1的左子树高度为2,右子树高度为0,差值为2 > 1

代码实现

public static boolean balance;

public static boolean isBalanced(TreeNode root) {
    // 每次调用都重置全局标志
    balance = true;
    height(root);
    return balance;
}

public static int height(TreeNode cur) {
    // 剪枝:一旦发现不平衡,或遇到空节点,直接返回
    if (!balance || cur == null) {
       return 0;
    }
    
    // 递归计算左右子树高度
    int lh = height(cur.left);
    int rh = height(cur.right);
    
    // 检查当前节点是否平衡
    if (Math.abs(lh - rh) > 1) {
       balance = false;
    }
    
    // 返回当前节点的高度
    return Math.max(lh, rh) + 1;
}

如果觉得有帮助，欢迎点赞、关注、转发~

算法详解-二叉树路径总和问题——DFS+回溯完整题解-Java实现

Thu, 06 Nov 2025 21:00:24 +0000

求解思路

从根节点出发，沿着路径向下遍历，记录当前路径经过的所有节点。当到达叶子节点时，判断路径和是否等于目标值。然后回溯到父节点，继续探索其他路径，直到遍历完所有可能的路径。

递归流程分析

1. 叶子节点的处理

if (cur.left == null && cur.right == null) {
    // 到达叶子节点
    if (cur.val + sum == aim) {
        path.add(cur.val);           // 加入当前节点
        copy(path, ans);             // 拷贝路径到结果集
        path.remove(path.size() - 1); // 回溯，移除当前节点
    }
}

2. 非叶子节点的处理

else {
    path.add(cur.val);              // 做选择: 加入当前节点
    
    if (cur.left != null) {
        f(cur.left, aim, sum + cur.val, path, ans);  // 递归左子树
    }
    if (cur.right != null) {
        f(cur.right, aim, sum + cur.val, path, ans); // 递归右子树
    }
    
    path.remove(path.size() - 1);   // 撤销选择: 回溯
}

完整代码实现

public static List<List<Integer>> pathSum(TreeNode root, int aim) {
    List<List<Integer>> ans = new ArrayList<>();
    if (root != null) {
       List<Integer> path = new ArrayList<>();
       f(root, aim, 0, path, ans);
    }
    return ans;
}

public static void f(TreeNode cur, int aim, int sum, 
                     List<Integer> path, List<List<Integer>> ans) {
    if (cur.left == null && cur.right == null) {
       // 叶节点
       if (cur.val + sum == aim) {
          path.add(cur.val);
          copy(path, ans);
          path.remove(path.size() - 1);
       }
    } else {
       // 非叶节点
       path.add(cur.val);
       if (cur.left != null) {
          f(cur.left, aim, sum + cur.val, path, ans);
       }
       if (cur.right != null) {
          f(cur.right, aim, sum + cur.val, path, ans);
       }
       path.remove(path.size() - 1);
    }
}

public static void copy(List<Integer> path, List<List<Integer>> ans) {
    List<Integer> copy = new ArrayList<>();
    for (Integer num : path) {
       copy.add(num);
    }
    ans.add(copy);
}

如果觉得有帮助，欢迎点赞、关注、转发~

一次遍历搞定二叉搜索树的最近公共祖先

Wed, 05 Nov 2025 20:14:15 +0000

求解思路

因为二叉搜索树(BST)，左子树的所有节点值 < 根节点值，右子树的所有节点值 > 根节点值，利用 BST 的这个有序性，通过比较节点值来判断：

如果 root 等于 p 或 q，直接返回 root
如果 root 的值在 p 和 q 之间，说明 p 和 q 分居两侧，也是直接返回 root
如果 root 小于 p 和 q，说明两者都在右子树，向右走
如果 root 大于 p 和 q，说明两者都在左子树，向左走

代码实现

public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    // 从根节点开始向下遍历
    while (root.val != p.val && root.val != q.val) {
        // 如果 root 在 p 和 q 之间，说明找到了分叉点
        if (Math.min(p.val, q.val) < root.val && root.val < Math.max(p.val, q.val)) {
            break;
        }
        // p 和 q 都比 root 小，往左走；否则往右走
        root = root.val < Math.min(p.val, q.val) ? root.right : root.left;
    }
    return root;
}

如果觉得有帮助，欢迎点赞、关注、转发~

如何优雅地找到二叉树的最近公共祖先

Tue, 04 Nov 2025 20:49:45 +0000

核心思路

从根节点开始,向左右子树递归搜索目标节点,然后根据左右子树的返回结果判断最近公共祖先的位置。

1.递归终止条件

1
2
3

if (root == null || root == p || root == q) {
    return root;
}

如果搜索到了空节点,说明这条路径上没有找到目标节点；

如果当前节点就是我们要找的节点之一,直接返回。

2.向左右子树递归搜索

1
2

TreeNode l = lowestCommonAncestor(root.left, p, q);
TreeNode r = lowestCommonAncestor(root.right, p, q);

分别在左子树和右子树中搜索 p 和 q。

3.根据搜索结果判断

(1) p 和 q 分别在当前节点的左右两侧,那么当前节点 root 就是它们的最近公共祖先。

1
2
3

if (l != null && r != null) {
    return root;
}

(2)左右子树都返回 null,说明当前子树中既没有 p 也没有 q。

1
2
3

if (l == null && r == null) {
    return null;
}

(3)当 l 和 r 一个为空、一个不为空时,返回非空的那个结果。

`1`	`return l != null ? l : r;`

代码实现

public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if (root == null || root == p || root == q) {
        // 遇到空,或者p,或者q,直接返回
        return root;
    }
    
    TreeNode l = lowestCommonAncestor(root.left, p, q);
    TreeNode r = lowestCommonAncestor(root.right, p, q);
    
    if (l != null && r != null) {
        // 左树也搜到,右树也搜到,返回root
        return root;
    }
    
    if (l == null && r == null) {
        // 都没搜到返回空
        return null;
    }
    
    // l和r一个为空,一个不为空
    // 返回不空的那个
    return l != null ? l : r;
}

如果觉得有帮助，欢迎点赞、关注、转发~

太强了!这个算法让面试官当场惊呼-你是怎么想到的

Mon, 03 Nov 2025 20:30:29 +0000

如果是普通二叉树，我们只能老老实实遍历每个节点,时间复杂度为O(N)。

但完全二叉树有特殊的结构性质，利用完全二叉树的特性，我们可以将时间复杂度优化到O(logN × logN)。

如果左子树是满二叉树，由满二叉树的节点数公式2^h - 1(h为高度)，可以直接算出左子树节点数，之后只需递归右子树。

反之，如果右子树是满的，则左子树需要继续递归。

代码逻辑

1. 主函数入口

public static int countNodes(TreeNode head) {
    if (head == null) {
        return 0;
    }
    return f(head, 1, mostLeft(head, 1));
}

2. 计算树的高度

public static int mostLeft(TreeNode cur, int level) {
    while (cur != null) {
        level++;
        cur = cur.left;
    }
    return level - 1;
}

3. 递归函数

public static int f(TreeNode cur, int level, int h) {
    if (level == h) {
        return 1;
    }
    if (mostLeft(cur.right, level + 1) == h) {
        // 情况1:右子树的最左节点到达最深层
        return (1 << (h - level)) + f(cur.right, level + 1, h);
    } else {
        // 情况2:右子树的最左节点未到达最深层
        return (1 << (h - level - 1)) + f(cur.left, level + 1, h);
    }
}

完整代码

    public static int countNodes(TreeNode head) {
        if (head == null) {
            return 0;
        }
        return f(head, 1, mostLeft(head, 1));
    }

    public static int f(TreeNode cur, int level, int h) {
        if (level == h) {
            return 1;
        }
        if (mostLeft(cur.right, level + 1) == h) {
            return (1 << (h - level)) + f(cur.right, level + 1, h);
        } else {
            return (1 << (h - level - 1)) + f(cur.left, level + 1, h);
        }
    }

    public static int mostLeft(TreeNode cur, int level) {
        while (cur != null) {
            level++;
            cur = cur.left;
        }
        return level - 1;
    }

如果觉得有帮助，欢迎点赞、关注、转发~

一道面试高频题-如何判断完全二叉树

Sun, 02 Nov 2025 19:06:03 +0000

解题思路

用一个队列按层遍历所有节点，同时检测2个关键条件：

1.不能出现"有右无左"

如果某个节点只有右孩子没有左孩子，直接判定为非完全二叉树。

     1
    / \
   2   3
    \      ← 节点2只有右孩子，违规！
     5

2.遇到"不双全"节点后，后续必须都是叶子节点

一旦遇到左右孩子不双全的节点（只有左孩子或两个都没有），那么后面的所有节点都必须是叶子节点。

     1
    / \
   2   3
  /         ← 节点2只有左孩子，后面的节点3必须是叶子
 4

代码实现

public static int MAXN = 101;
public static TreeNode[] queue = new TreeNode[MAXN];
public static int l, r;  // l是队头指针，r是队尾指针

public static boolean isCompleteTree(TreeNode h) {
    if (h == null) {
        return true;  // 空树认为是完全二叉树
    }
    
    // 初始化队列
    l = r = 0;
    queue[r++] = h;
    
    // leaf标记：是否遇到过"不双全"的节点
    boolean leaf = false;
    
    while (l < r) {
        h = queue[l++];  // 出队
        
        // 两种违规情况
        if ((h.left == null && h.right != null) ||  // 情况1：有右无左
            (leaf && (h.left != null || h.right != null))) {  // 情况2：遇到leaf标记后还有孩子
            return false;
        }
        
        // 左孩子入队
        if (h.left != null) {
            queue[r++] = h.left;
        }
        
        // 右孩子入队
        if (h.right != null) {
            queue[r++] = h.right;
        }
        
        // 如果当前节点不双全，标记leaf
        if (h.left == null || h.right == null) {
            leaf = true;
        }
    }
    
    return true;
}

如果觉得有帮助，欢迎点赞、关注、转发~

大厂面试官不会告诉你-重建二叉树有这个捷径

Sat, 01 Nov 2025 19:59:29 +0000

这是一道二叉树的经典问题，不仅考察对二叉树遍历的理解，更考验递归思维和边界处理能力。

核心思路

采用分治思想:

通过前序遍历确定根节点,在中序遍历中定位该根节点的位置,以此为分界点划分出左右子树的范围,然后递归地对左右子树重复这个过程,最终完成整棵树的重建。

索引计算的推导

假设:

1
2
3

前序遍历: pre[l1 ... r1]
中序遍历: in[l2 ... r2]
根节点在中序中的位置: k

1.中序遍历的划分

根节点 k 天然就是分界点:

1
2

中序: [l2 ... k-1] | k | [k+1 ... r2]
       ← 左子树 →   根   ← 右子树 →

左子树范围: in[l2, k-1]
右子树范围: in[k+1, r2]

2.前序遍历的划分

1
2

pre[l1] | pre[l1+1 ... ?] | pre[? ... r1]
  根节点     左子树          右子树

已知左子树有 k - l2 个节点，所以:

1
2

pre[l1] | pre[l1+1 ... l1+(k-l2)] | pre[l1+(k-l2)+1 ... r1]
  根         左子树(k-l2个节点)          右子树

左子树范围: pre[l1+1, l1+k-l2]
右子树范围: pre[l1+k-l2+1, r1]

拿示例1举例

假设输入:

1
2

前序遍历: [3, 9, 20, 15, 7]
中序遍历: [9, 3, 15, 20, 7]

第1步: 前序首元素 3 是根节点,在中序中位置为 1

1
2

中序: [9] | 3 | [15, 20, 7]
       左     根      右

第2步: 递归处理左子树 [9] 和右子树 [20, 15, 7]

第3步: 右子树中,20 是根节点,继续划分…

最终构建出:

代码实现

public static TreeNode buildTree(int[] pre, int[] in) {
    // 边界检查
    if (pre == null || in == null || pre.length != in.length) {
        return null;
    }
    
    // 构建哈希表:值 → 在中序遍历中的索引
    HashMap<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < in.length; i++) {
        map.put(in[i], i);
    }
    
    return f(pre, 0, pre.length - 1, in, 0, in.length - 1, map);
}

public static TreeNode f(int[] pre, int l1, int r1, 
                         int[] in, int l2, int r2, 
                         HashMap<Integer, Integer> map) {
    // 递归终止条件
    if (l1 > r1) {
        return null;
    }
    
    // 创建根节点
    TreeNode head = new TreeNode(pre[l1]);
    
    // 只有一个节点时直接返回
    if (l1 == r1) {
        return head;
    }
    
    // 在中序遍历中找到根节点位置
    int k = map.get(pre[l1]);
    
    // 递归构建左右子树
    head.left = f(pre, l1 + 1, l1 + k - l2, in, l2, k - 1, map);
    head.right = f(pre, l1 + k - l2 + 1, r1, in, k + 1, r2, map);
    
    return head;
}

如果觉得有帮助，欢迎点赞、关注、转发~

二叉树序列化与反序列化

Fri, 31 Oct 2025 21:58:22 +0000

在实际开发中，经常需要将二叉树保存到文件或通过网络传输。这就需要将树结构转换为字符串（序列化），以及从字符串恢复树结构（反序列化）。

今天就来剖析这个序列化和反序列化的问题。

🚀解题思路

🟦 用 前序遍历（根→左→右） 把树“拍扁”成字符串 🟦 用 # 表示空节点 🟦 反序列化时，递归按顺序读回来

这样就能保证序列化和反序列化是一一对应的。

💻 完整代码

public class Codec {

    // 序列化：将二叉树转成字符串
    public String serialize(TreeNode root) {
        StringBuilder builder = new StringBuilder();
        f(root, builder);
        return builder.toString();
    }

    // 前序遍历构建字符串
    void f(TreeNode root, StringBuilder builder) {
        if (root == null) {
            builder.append("#,");  // 用#表示null节点
        } else {
            builder.append(root.val + ",");  // 当前节点值
            f(root.left, builder);           // 递归左子树
            f(root.right, builder);          // 递归右子树
        }
    }

    // 反序列化：将字符串还原为二叉树
    public TreeNode deserialize(String data) {
        String[] vals = data.split(",");
        cnt = 0;
        return g(vals);
    }

    // 当前解析到数组的第几个元素
    public static int cnt;

    // 递归构建树
    TreeNode g(String[] vals) {
        String cur = vals[cnt++];
        if (cur.equals("#")) {
            return null;  // 空节点
        } else {
            TreeNode head = new TreeNode(Integer.valueOf(cur));
            head.left = g(vals);
            head.right = g(vals);
            return head;
        }
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

二叉树最大深度与最小深度-一文搞懂递归的精髓与陷阱

Thu, 30 Oct 2025 20:51:38 +0000

二叉树的最大深度

代码逻辑

当遇到空节点时返回深度 0 作为递归的终止条件，否则分别递归计算左右子树的深度，取两者中的较大值后加 1（这个 +1 代表当前节点本身占据的一层），最终得到以当前节点为根的子树的最大深度。

代码实现

1
2
3

public static int maxDepth(TreeNode root) {
    return root == null ? 0 : Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}

二叉树的最小深度

代码逻辑

代码通过三层判断来确保找到真正的最小深度：

首先判断空树直接返回 0，其次判断叶子节点（左右子树都为空）直接返回 1，最后对于有子树的节点，将左右深度初始化为 Integer.MAX_VALUE，只有当某侧子树存在时才递归计算其真实深度，这样在取 min 时会自动忽略不存在的子树（因为 MAX_VALUE 必然更大），最终加 1 得到当前节点的最小深度。

代码实现

public int minDepth(TreeNode root) {
    if (root == null) {
        // 空树深度为 0
        return 0;
    }
    if (root.left == null && root.right == null) {
        // 当前节点是叶子节点
        return 1;
    }
    
    int ldeep = Integer.MAX_VALUE;
    int rdeep = Integer.MAX_VALUE;
    
    if (root.left != null) {
        ldeep = minDepth(root.left);
    }
    if (root.right != null) {
        rdeep = minDepth(root.right);
    }
    
    return Math.min(ldeep, rdeep) + 1;
}

二叉树最大宽度-学会这个技巧-类似题目秒杀

Wed, 29 Oct 2025 20:25:06 +0000

代码逻辑

这道题就是给每个节点编号，根节点是1，然后左子节点就是父节点编号乘2，右子节点是父节点编号乘2再加1。

层序遍历的时候，每一层的宽度就等于这层最右边的编号减去最左边的编号再加1，把所有层遍历一遍取个最大值就行了。

代码里用 nq[] 存节点，iq[] 存对应的编号，l 和 r 两个指针来模拟队列操作。

完整代码

public static int MAXN = 3001;
public static TreeNode[] nq = new TreeNode[MAXN];  // 节点队列
public static int[] iq = new int[MAXN];            // 编号队列
public static int l, r;                            // 队列的左右指针

public static int widthOfBinaryTree(TreeNode root) {
    int ans = 1;
    l = r = 0;
    
    // 初始化：根节点入队，编号为1
    nq[r] = root;
    iq[r++] = 1;
    
    while (l < r) {
        int size = r - l;  // 当前层的节点数量
        
        // 计算当前层的宽度
        ans = Math.max(ans, iq[r - 1] - iq[l] + 1);
        
        // 处理当前层的所有节点
        for (int i = 0; i < size; i++) {
            TreeNode node = nq[l];
            int id = iq[l++];
            
            // 左子节点入队
            if (node.left != null) {
                nq[r] = node.left;
                iq[r++] = id * 2;
            }
            
            // 右子节点入队
            if (node.right != null) {
                nq[r] = node.right;
                iq[r++] = id * 2 + 1;
            }
        }
    }
    
    return ans;
}

二叉树的锯齿形层序遍历

Tue, 28 Oct 2025 20:45:37 +0000

代码逻辑

这道题如果用队列（Queue）来做层序遍历，然后每层根据奇偶性决定是正序还是反序。

这样操作会遇到一些麻烦，比如用双端队列（Deque），需要频繁在两端操作；如果用普通队列，收集结果时需要反转列表。

今天分享一种解法：

用一个静态数组模拟队列，通过索引控制实现锯齿形遍历。

1. 用数组模拟队列

1
2

public static TreeNode[] queue = new TreeNode[MAXN];
public static int l, r;  // l是队头，r是队尾

2. 双循环结构

第一个循环：收集当前层的节点值

for (int i = reverse ? r - 1 : l, j = reverse ? -1 : 1, k = 0; 
     k < size; 
     i += j, k++) {
    TreeNode cur = queue[i];
    list.add(cur.val);
}

如果 reverse == false（从左到右）：i 从 l 开始，每次 +1；

如果 reverse == true（从右到左）：i 从 r-1 开始，每次 -1；

第二个循环：扩展下一层节点

for (int i = 0; i < size; i++) {
    TreeNode cur = queue[l++];  // 从队头取出
    if (cur.left != null) {
        queue[r++] = cur.left;   // 放入队尾
    }
    if (cur.right != null) {
        queue[r++] = cur.right;
    }
}

按照左到右的顺序处理节点，把下一层的节点依次加入队列。

完整代码

public static int MAXN = 2001;
	public static TreeNode[] queue = new TreeNode[MAXN];
	public static int l, r;  // l是队头，r是队尾

	public static List<List<Integer>> zigzagLevelOrder(TreeNode root){
		List<List<Integer>> ans = new ArrayList<>();
		if(root!=null){
			l=r=0;
			queue[r++]=root;
			boolean reverse = false;
			while(l<r){
				int size = r-l;
				ArrayList<Integer> list = new ArrayList<>();
				for(int i=reverse?r-1:l,j=reverse?-1:1,k=0;k<size;i+=j,k++){
					TreeNode cur = queue[i];
					list.add(cur.val);
				}
				for (int i = 0; i < size; i++) {
					TreeNode cur = queue[l++];  // 从队头取出
					if (cur.left != null) {
						queue[r++] = cur.left;   // 放入队尾
					}
					if (cur.right != null) {
						queue[r++] = cur.right;
					}
				}
				ans.add(list);
				reverse = !reverse;
			}
		}
		return ans;
	}

二叉树层序遍历-90%的人都用错了方法！

Mon, 27 Oct 2025 21:50:37 +0000

今天来聊聊二叉树的层序遍历问题。这道题在面试中的出镜率极高,是 BFS(广度优先搜索)的经典应用。

方法1:HashMap 记录层级

代码逻辑

核心是用 HashMap 记录每个节点所在的层级。

先将根节点入队并标记为第 0 层,然后逐个出队处理节点,根据 HashMap 中的层级信息将节点值放入对应层的列表中,同时将子节点入队并标记为下一层。这样通过 HashMap 作为"层级标签",让每个节点都能准确找到自己该归属的那一层。

代码实现

public static List<List<Integer>> levelOrder1(TreeNode root) {
    List<List<Integer>> ans = new ArrayList<>();
    if (root != null) {
        Queue<TreeNode> queue = new LinkedList<>();
        HashMap<TreeNode, Integer> levels = new HashMap<>();
        
        queue.add(root);
        levels.put(root, 0); // 根节点在第0层
        
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            int level = levels.get(cur);
            
            // 如果当前层还没有列表,就创建一个
            if (ans.size() == level) {
                ans.add(new ArrayList<>());
            }
            
            // 将当前节点加入对应层
            ans.get(level).add(cur.val);
            
            // 将子节点加入队列,并记录它们的层级
            if (cur.left != null) {
                queue.add(cur.left);
                levels.put(cur.left, level + 1);
            }
            if (cur.right != null) {
                queue.add(cur.right);
                levels.put(cur.right, level + 1);
            }
        }
    }
    return ans;
}

方法2:按层处理优化

代码逻辑

在每轮循环开始时,先用 size = r - l 记录当前队列中有多少个节点(即当前层的节点数),然后用 for 循环恰好处理这 size 个节点,在出队收集节点值的同时将下一层节点入队,这样每轮循环恰好完成一层的遍历。

代码实现

public static int MAXN = 2001;
public static TreeNode[] queue = new TreeNode[MAXN];
public static int l, r; // l:队列头指针, r:队列尾指针

public static List<List<Integer>> levelOrder2(TreeNode root) {
    List<List<Integer>> ans = new ArrayList<>();
    if (root != null) {
        l = r = 0;
        queue[r++] = root;
        
        while (l < r) {
            int size = r - l; // 当前层的节点数量
            ArrayList<Integer> list = new ArrayList<>();
            
            // 处理当前层的所有节点
            for (int i = 0; i < size; i++) {
                TreeNode cur = queue[l++];
                list.add(cur.val);
                
                if (cur.left != null) {
                    queue[r++] = cur.left;
                }
                if (cur.right != null) {
                    queue[r++] = cur.right;
                }
            }
            
            ans.add(list);
        }
    }
    return ans;
}

面试官追问的堆排序细节-这篇讲透2种建堆方式

Sun, 05 Oct 2025 11:09:18 +0000

本文用大根堆来实现升序排序。

大根堆其实是一种特殊的“完全二叉树”，要求 “父节点的值大于子节点的值”。

在使用数组存储时有以下索引关系：

若父节点索引为i，则左孩子索引是2i+1，右孩子索引是2i+2；
若子节点索引为i，则父节点索引是(i-1)/2（整数除法，向下取整）。

heapInsert：向上调整

不断和父节点比较，若比父节点大就交换，直到父节点更大或到堆顶（索引 0）。

public static void heapInsert(int[] arr, int i) {
    // 父节点索引=(i-1)/2，只要当前元素>父节点，就交换
    while (arr[i] > arr[(i - 1) / 2]) {
        swap(arr, i, (i - 1) / 2);
        i = (i - 1) / 2; // 交换后，当前元素跑到父节点位置，继续向上比
    }
}

heapify：向下调整

先找左右孩子里的 “最大值”，再和当前元素比较，若孩子更大就交换，直到当前元素更大或没有孩子。

public static void heapify(int[] arr, int i, int size) {
    int l = i * 2 + 1; // 左孩子索引
    while (l < size) { // 只要有左孩子，就继续循环
        // 1. 选左右孩子中的最大值（若有右孩子，且右孩子>左孩子，则选右）
        int best = (l + 1 < size && arr[l + 1] > arr[l]) ? l + 1 : l;
        // 2. 比较“最大值”和当前元素，选更大的那个
        best = arr[best] > arr[i] ? best : i;
        // 3. 若当前元素已是最大，说明堆结构ok，退出
        if (best == i) break;
        // 4. 否则交换，继续向下沉
        swap(arr, best, i);
        i = best; 
        l = i * 2 + 1; 
    }
}

方式一：heapSort（从顶到底建堆）

把数组当 “空堆”，逐个元素插入堆尾，用 heapInsert 向上调整

public static void heapSort(int[] arr) {
    int n = arr.length;
    // 从顶到底建堆
    for (int i = 0; i < n; i++) {
        heapInsert(arr, i); 
    }
    // 排序（反复交换堆顶和堆尾，向下调整）
    int size = n; 
    while (size > 1) {
        // 交换堆顶（最大值）和堆尾元素，最大值放到最终位置
        swap(arr, 0, --size);
        // 堆顶元素变了，向下调整维持大根堆
        heapify(arr, 0, size);
    }
}

方式二：heapSort（从底到顶建堆）

从 “最后一个非叶子节点” 开始，用 heapify 向下调整，直到堆顶。

public static void heapSort2(int[] arr) {
    int n = arr.length;
    // 从底到顶建堆（从最后一个节点开始，向下调整）
    for (int i = n - 1; i >= 0; i--) {
        heapify(arr, i, n); 
    }
    // 排序
    int size = n;
    while (size > 1) {
        swap(arr, 0, --size);
        heapify(arr, 0, size);
    }
}

代码

链接：https://pan.quark.cn/s/d943e41053e1

提取码：XzdV

二叉树的后序遍历-非递归版

Mon, 29 Sep 2025 21:27:09 +0000

本文约定用“打印”这个术语来表示执行某个操作。

用两个栈来实现

先头节点入栈，然后弹出节点但是接着不打印，而是再次放到一个收集栈里，然后先压左子树再压右子树，这样原本弹出栈的顺序应该是根右左，但是经过这个收集栈之后就变成了左右根，这样的话就能够实现后序遍历。

代码实现

public static List<Integer> postorderTraversal(TreeNode head) {
		List<Integer> ans = new ArrayList<>();
		if(head!=null){
			Stack<TreeNode> stack = new Stack<>();
			Stack<TreeNode> collect = new Stack<>();
			stack.push(head);
			while(!stack.isEmpty()){
				head = stack.pop();
				collect.push(head);

				if(head.left!=null){
					stack.push(head.left);
				}

				if(head.right!=null){
					stack.push(head.right);
				}
			}

			while (!collect.isEmpty()){
				ans.add(collect.pop().val);
			}
		}
		return ans;
	}

用一个栈来实现

刚开始，我们用h来表示头节点，如果始终没有打印过节点，则h就一直是头节点。一旦打印过节点，则h就变成上一次打印的节点。如果有左子树并且左子树没有处理过，则左子树进栈。如果有右子树并且右子树没有处理过，则右子树进栈。如果左子树、右子树为空或者都处理过了，则打印并将h指向弹出的节点。

代码实现

public static List<Integer> postorderTraversal(TreeNode h) {
		List<Integer> ans = new ArrayList<>();
		if(h!=null){
			Stack<TreeNode> stack = new Stack<>();
			stack.push(h);
			while(!stack.isEmpty()){
				TreeNode cur = stack.peek();
				if(cur.left!=null&&h!=cur.left&&h!=cur.right){
					stack.push(cur.left);
				}else if(cur.right!=null&&h!=cur.right){
					stack.push(cur.right);
				}else{
					ans.add(cur.val);
					h=stack.pop();
				}
			}
		}
		return ans;
	}

非递归实现二叉树的中序遍历

Sun, 28 Sep 2025 20:40:28 +0000

二叉树的中序遍历

代码实现逻辑:

1)来到某一个子树的头节点，整条左边界进栈，一直到整条左边界遍历完；

2)从栈中弹出节点，打印（这里的打印是指可以做某个动作，比如此处是将节点值添加到结果链表），把弹出打印节点的右子树看作是新的子树的头节点，然后重复步骤1）； 3)当没有子树并且栈为空了，结束

注意如果右子树为空，可以假定它执行了比如步骤1)但是什么都没有干成，这样更好理解一些。

代码实现

	public static List<Integer> inorderTraversal(TreeNode head) {
		List<Integer> ans = new ArrayList<>();
		if(head!=null){
			Stack<TreeNode> stack = new Stack<>();
			while(!stack.isEmpty()||head!=null){
				if(head!=null){
					stack.push(head);
					head = head.left;
				}else {
					head = stack.pop();
					ans.add(head.val);
					head= head.right;
				}
			}
		}
		return ans;
	}