2021.1.19每日复习 103.二叉树的锯齿形层序遍历（BFS+DFS）+ 105.从前序与中序遍历序列构造二叉树（递归+迭代）

103.二叉树的锯齿形层序遍历（BFS+DFS）

//BFS
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
		List<List<Integer>> res = new ArrayList<>();
		if(root == null) return res;
		boolean flag = true; //true表示从左往右遍历
		//创建队列，保存节点
		LinkedList<TreeNode> queue = new LinkedList<>();
		queue.add(root); 
		while(!queue.isEmpty()) {
			List<Integer> temp = new ArrayList<>();
			int size = queue.size();
			for(int i = 0; i < size; i++) {
				TreeNode t = queue.poll();
				if(flag) temp.add(t.val);
				else temp.add(0, t.val);
				if(t.left != null) queue.add(t.left);
				if(t.right != null) queue.add(t.right);
			}
			res.add(temp);
			flag = !flag; //改变下次遍历的方向
		}
		return res;
    }
}

//DFS
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
		List<List<Integer>> res = new ArrayList<>();
		if(root == null) return res;
		dfs(root, 0, res);
		return res;
	}
	public void dfs(TreeNode root, int level, List<List<Integer>> res) {
		if(root == null) return;
		if(level >= res.size()) {
			res.add(new ArrayList<>());
		}
		List<Integer> list = res.get(level);
		if(level % 2 == 0) list.add(root.val);
		else list.add(0, root.val);
		dfs(root.left, level + 1, res);
		dfs(root.right, level + 1, res);
	}
}

---

105.从前序与中序遍历序列构造二叉树（递归+迭代）

//DFS
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
		int preLen = preorder.length;
        int inLen = inorder.length;
        if(preLen != inLen) return null;
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < inLen; i++) {
            map.put(inorder[i], i);
        }
        return dfs(preorder, 0, preLen - 1, inorder, 0, inLen - 1, map);
    }
    public TreeNode dfs(int[] preorder, int preLeft, int preRight, int[] inorder, int inLeft, int inRight, Map<Integer, Integer> map) {
        if(preLeft > preRight || inLeft > inRight) {
            return null;
        }
        int pivot = preorder[preLeft];
        TreeNode root = new TreeNode(pivot);
        //int inMid = map.get(pivot);
        int inMid = inLeft;
        while(inorder[inMid] != pivot) inMid++;
        root.left = dfs(preorder, preLeft + 1, preLeft + inMid - inLeft, inorder, inLeft, inMid - 1, map);
        root.right = dfs(preorder, preLeft + inMid - inLeft + 1, preRight, inorder, inMid + 1, inRight, map);
        return root;
    }
}

//BFS
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder == null || preorder.length == 0) {
            return null;
        }
        TreeNode root = new TreeNode(preorder[0]);
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        stack.push(root);
        int inorderIndex = 0;
        for (int i = 1; i < preorder.length; i++) {
            int preorderVal = preorder[i];
            TreeNode node = stack.peek();
            if (node.val != inorder[inorderIndex]) {
                node.left = new TreeNode(preorderVal);
                stack.push(node.left);
            } else {
                while (!stack.isEmpty() && stack.peek().val == inorder[inorderIndex]) {
                    node = stack.pop();
                    inorderIndex++;
                }
                node.right = new TreeNode(preorderVal);
                stack.push(node.right);
            }
        }
        return root;
    }
}