跟着labuladong——学习算法和刷题的框架思维

先刷二叉树，先刷二叉树，先刷二叉树

二叉树最容易培养框架思维，大部分算法技巧，本质上都是树的遍历问题

二叉树框架：

void traverse (TreeNode root) {
    // 前序遍历代码位置
    traverse(root.left);
    // 中序遍历代码位置
    traverse(root.right);
    // 后续遍历代码位置
}

LeetCode 124题 hard

    int maxRes = Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        postOrder(root);
        return maxRes;
    }

    private int postOrder(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = Math.max(postOrder(root.left),0);
        int right = Math.max(postOrder(root.right),0);

        maxRes = Math.max(maxRes,left+right+root.val);
        return root.val+Math.max(left,right);
    }

也可以练习下549 题型相同哦

LeetCode 105 Medium

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int preLen = preorder.length;
        int inLen = inorder.length;
        if(preLen != inLen){
            throw new RuntimeException("Incorrect input data.");
        }
        Map<Integer,Integer> map = new HashMap<>(preLen);
        for(int i = 0; i < inLen; i++) {
            map.put(inorder[i],i);
        }
        return buildTree(preorder,0, preLen-1, map, 0, inLen-1);
    }

    private TreeNode buildTree(int[] preorder, int preLeft, int preRight,
        Map<Integer, Integer> map, int inLeft, int inRight) {
        if (preLeft > preRight || inLeft >inRight) {
            return null;
        }
        int rootVal = preorder[preLeft];
        TreeNode root = new TreeNode(rootVal);
        int pIndex = map.get(rootVal);
        root.left = buildTree(preorder,preLeft+1,pIndex-inLeft+preLeft,map,inLeft,pIndex-1);
        root.right = buildTree(preorder,pIndex-inLeft+preLeft+1,preRight,map,pIndex+1,inRight);
        return root;
    }

LeetCode 99 Hard

    TreeNode errorOne;
    TreeNode errorTwo;
    public void recoverTree(TreeNode root) {
        errorOne = null;
        errorTwo = null;

        findInOrder(root);
        int temp = errorOne.val;
        errorOne.val = errorTwo.val;
        errorTwo.val = temp;
    }

    private void findInOrder(TreeNode root) {
        TreeNode pre = null;
        Stack<TreeNode> stack = new Stack<>();
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if(pre != null && pre.val > root.val){
                if(errorOne == null){
                    errorOne = pre;
                    errorTwo = root;
                }else {
                    errorTwo = root;
                }
            }
            pre = root;
            root = root.right;
        }
    }