leecodecode【面试150】【2026.6.24打卡-java版本】

从前序与中序遍历序列构造二叉树

要点：工具前序的根节点，在中序划分左右子树

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 {
    //分前后，root，
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        if(n ==0){
            return null;
        }
        int leftsize = indexof(preorder[0], inorder);
        int[] pre1 = Arrays.copyOfRange(preorder, 1, 1+leftsize);
        int[] pre2 = Arrays.copyOfRange(preorder, 1+leftsize,n);
        int[] in1 = Arrays.copyOfRange(inorder,0,leftsize);
        int[] in2 = Arrays.copyOfRange(inorder,1+leftsize, n);
        TreeNode left = buildTree(pre1, in1);
        TreeNode right = buildTree(pre2, in2);
        return new TreeNode(preorder[0], left, right);
    }

    private int indexof( int x ,int[] a){
        for(int i = 0; i<a.length; i++){
            if(a[i] == x){
                return i;
            }
        }

        return -1;
    }
}

从中序与后序遍历序列构造二叉树

要点：同上

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 TreeNode buildTree(int[] inorder, int[] postorder) {
        int n = postorder.length;
        if (n == 0) { // 空节点
            return null;
        }
        int leftSize = indexOf(inorder, postorder[n - 1]); // 左子树的大小
        int[] in1 = Arrays.copyOfRange(inorder, 0, leftSize);
        int[] in2 = Arrays.copyOfRange(inorder, leftSize + 1, n);
        int[] post1 = Arrays.copyOfRange(postorder, 0, leftSize);
        int[] post2 = Arrays.copyOfRange(postorder, leftSize, n - 1);
        TreeNode left = buildTree(in1, post1);
        TreeNode right = buildTree(in2, post2);
        return new TreeNode(postorder[n - 1], left, right);
    }

    // 返回 x 在 a 中的下标，保证 x 一定在 a 中
    private int indexOf(int[] a, int x) {
        for (int i = 0; ; i++) {
            if (a[i] == x) {
                return i;
            }
        }
    }
}

填充每个节点的下一个右侧节点指针 II

要点：层次遍历

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 null;
        }
        List<Node> q = List.of(root);

        while(!q.isEmpty()){
            List<Node> temp = q;
            q = new ArrayList<>();

            for(int i = 0; i < temp.size(); i++){
                Node node = temp.get(i);

                if(i > 0){
                    temp.get(i-1).next = node;
                }

                if(node.left != null){
                    q.add(node.left);
                }

                if(node.right != null){
                    q.add(node.right);
                }
            }
        }

        return root;
        
    }
}

二叉树展开为链表

要点：dfs

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 void flatten(TreeNode root) {
        dfs(root);
    }

    private TreeNode dfs(TreeNode root){
        if(root == null){
            return null;
        }

        TreeNode leftTail = dfs(root.left);
        TreeNode rightTail = dfs(root.right);

        if(leftTail != null){
            leftTail.right  = root.right;
            root.right = root.left;
            root.left = null;
        }

        if (rightTail != null) {
            return rightTail;
        } else if (leftTail != null) {
            return leftTail;
        } else {
            return root;
        }
    }
}

碎碎念：后续会更新每天学习的八股和算法题，开始准备秋招的第45天。努力连续更新100天！以后每天就按，秋招项目【java +agent】，科研，必做项目，算法，八股，锻炼身体来总结。

总结：没状态

1.算法面试150 87/150 2h

2.秋招项目，【java 项目】，【修改，2h】，

【agent 项目】，【修改，1h】，

3.科研要跑一下，2-3h，

4.检测项目，

6.背八股，

7.锻炼身体，无