算法-. 二叉树的层序遍历、最大深度

题目一、给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

二叉树的层序遍历

首先什么是层序遍历 层序遍历？看这一篇就够了！_BNDSllx的博客-CSDN博客_层序遍历

DFS（深度优先搜索）和 BFS（广度优先搜索），BFS 的使用场景总结：层序遍历、最短路径问题---力扣

如果我们使用 DFS/BFS 只是为了遍历一棵树、一张图上的所有结点的话，那么 DFS 和 BFS 的能力没什么差别，我们当然更倾向于更方便写、空间复杂度更低的 DFS 遍历。不过，某些使用场景是 DFS 做不到的，只能使用 BFS 遍历。这就是本文要介绍的两个场景：「层序遍历」、「最短路径」。而前中后序的遍历可以使用DFS来进行

解法一：使用了队列的尾部插入进行循环获取,这种也叫做广度优先遍历

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<>();
        if (root == null) {
            return lists;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        Deque<TreeNode> deque2 = new LinkedList<>();
        deque.push(root);

        while (!deque.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            while (!deque.isEmpty()) {
                TreeNode pop = deque.pop();
                list.add(pop.val);
                if (pop.left != null) {
                    deque2.offer(pop.left);
                }
                if (pop.right != null) {
                    deque2.offer(pop.right);
                }
            }
            lists.add(list);
             if(deque.isEmpty() &&deque2.isEmpty()){
                return lists;
            }
     
            deque.addAll(deque2);
            deque2.clear();
        }
        return lists;
    }

解法二、

这里对递归有一个清晰的讲解：

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/die-dai-di-gui-duo-tu-yan-shi-102er-cha-shu-de-cen/


 

相当于维护了一个层数标示，然后使用深度遍历讲数据一一对应填入

class Solution {
	public List<List<Integer>> levelOrder(TreeNode root) {
		if(root==null) {
			return new ArrayList<List<Integer>>();
		}
		//用来存放最终结果
		List<List<Integer>> res = new ArrayList<List<Integer>>();
		dfs(1,root,res);
		return res;
	}
	
	void dfs(int index,TreeNode root, List<List<Integer>> res) {
		//假设res是[ [1],[2,3] ]， index是3，就再插入一个空list放到res中
		if(res.size()<index) {
			res.add(new ArrayList<Integer>());
		}
		//将当前节点的值加入到res中，index代表当前层，假设index是3，节点值是99
		//res是[ [1],[2,3] [4] ]，加入后res就变为 [ [1],[2,3] [4,99] ]
		res.get(index-1).add(root.val);
		//递归的处理左子树，右子树，同时将层数index+1
		if(root.left!=null) {
			dfs(index+1, root.left, res);
		}
		if(root.right!=null) {
			dfs(index+1, root.right, res);
		}
	}
}

题目二、二叉树的最大深度

二叉树的最大深度--leetcode

这个题就是典型的深度优先搜索

解法一、迭代一

public int maxDepth = 0;


    public int maxDepth(TreeNode root) {

        int maxDepthTemp = 0;
        maxNode(root,maxDepthTemp);
        return maxDepth;
    }

    private void maxNode(TreeNode root, int maxDepthTemp) {

        if(root ==null){
            return ;
        }
        maxDepthTemp++;
        if(root.left ==null && root.right == null){
            maxDepth = Math.max(maxDepth,maxDepthTemp);
            return;
        }
        maxNode(root.left, maxDepthTemp);
        maxNode(root.right, maxDepthTemp);
    }

解法二、迭代二

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        } else {
            int leftHeight = maxDepth(root.left);
            int rightHeight = maxDepth(root.right);
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }
}

解法三、广度优先搜索

广度搜索的时候，把每一行的循环锁死，然后一行加一个，加到最深的一行即为深度

public int maxDepth(TreeNode root) {
        if(root ==null){
            return 0;
        }
        int max = 0;
        Deque<TreeNode> deque =  new LinkedList<TreeNode>();
        deque.offer(root);
        int ans = 0;
        while(!deque.isEmpty()){
            int size = deque.size();
            while (size>0){
                TreeNode poll = deque.poll();

                if(poll.left!=null){
                    deque.offer(poll.left);
                }
                if(poll.right!=null){
                    deque.offer(poll.right);
                }
                size--;
            }
            ans++;
        }
        return ans;
    }