第26天--算法(Leetcode 103,104,105,106,108)

103.二叉树的锯齿形层序遍历

 

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) {
            return res;
        }
        LinkedList<TreeNode> temp = new LinkedList<>();
        temp.add(root);
        Boolean isZheng = true;
        while(!temp.isEmpty()) {
            List<Integer> cur = new ArrayList<>();
            int size = temp.size();
            for(int i = 0;i < size;i ++) {
                if(isZheng) {
                    TreeNode t = temp.pollFirst();
                    cur.add(t.val);
                    if(t.left != null) {
                        temp.add(t.left);
                    }
                    if(t.right != null) {
                        temp.add(t.right);
                    }
                }else {
                    TreeNode t = temp.pollLast();
                    cur.add(t.val);
                    if(t.right != null) {
                        temp.addFirst(t.right);
                    }
                    if(t.left != null) {
                        temp.addFirst(t.left);
                    }
                }
            }
            isZheng = !isZheng;
            res.add(cur);
        }
        return res;
    }

 

104.二叉树的最大深度

public int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        if(root.left == null && root.right == null) {
            return 1;
        }
        return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
    }
105.从前序与中序遍历构造二叉树
public TreeNode buildTree(int[] preorder, int[] inorder) {
        HashMap<Integer,Integer> hm = new HashMap<>();
        for(int i = 0;i < inorder.length;i ++) {
            hm.put(inorder[i],i);
        }
        return process(preorder,0,preorder.length - 1,inorder,0,inorder.length - 1,hm);
    }
    public TreeNode process(int pre[],int L1,int R1,int in[],int L2,int R2,HashMap<Integer,Integer> hm) {
        if(L1 > R1) {
            return null;
        }
        TreeNode res = new TreeNode(pre[L1]);
        if(L1 == R1) {
            return res;
        }
        int findIndex = hm.get(pre[L1]);
        res.left = process(pre,L1 + 1,L1 + findIndex - L2,in,L2,findIndex - 1,hm);
        res.right = process(pre,L1 + findIndex - L2 + 1,R1,in,findIndex + 1,R2,hm);
        return res;
    }
106.从中序与后序遍历序列构造二叉树
public TreeNode buildTree(int[] inorder, int[] postorder) {
        HashMap<Integer,Integer> hm = new HashMap<>();
        for(int i = 0;i < inorder.length;i ++) {
            hm.put(inorder[i],i);
        }
        return process(inorder,0,inorder.length - 1,postorder,0,postorder.length - 1,hm);
    }
    public TreeNode process(int[] inorder,int L1,int R1,int[] postorder,int L2,int R2,HashMap<Integer,Integer> hm) {
        if(L1 > R1) {
            return null;
        }
        TreeNode res = new TreeNode(postorder[R2]);
        if(L1 == R1) {
            return res;
        }
        int findIndex = hm.get(postorder[R2]);
        res.left = process(inorder,L1,findIndex - 1,postorder,L2,L2 + findIndex - L1 - 1,hm);
        res.right = process(inorder,findIndex + 1,R1,postorder,L2 + findIndex - L1,R2 - 1,hm);
        return res;
    }
108.将有序数组转换为二叉搜索数
public TreeNode sortedArrayToBST(int[] nums) {
        return process(nums,0,nums.length - 1);
    }
    public TreeNode process(int[] nums,int L,int R) {
        if(L > R) {
            return null;
        }
        int mid = (L + R) / 2;
        TreeNode res = new TreeNode(nums[mid]);
        if(L == R) {
            return res;
        }
        res.left = process(nums,L,mid - 1);
        res.right = process(nums,mid + 1,R);
        return res;
    }
posted @ 2022-01-25 15:38  现在开始努力  阅读(63)  评论(0)    收藏  举报