重生之我在代码随想录刷算法第十一天 | 二叉树的递归遍历、二叉树的迭代遍历、二叉树的层序遍历-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_73210658/article/details/142466100

参考文献链接：代码随想录

本人代码是Java版本的，如有别的版本需要请上代码随想录网站查看。

二叉树的递归遍历

解题思路

递归遍历是比较简单的，我们只要搞清楚二叉树不同遍历的顺序即可。

前序遍历就是中左右，中序遍历就是左中右，后序遍历就是左右中。

我们只需要注意是先往左或往右继续遍历还是先添加中即可。

代码示例

//前序
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        preOrder(root,list);
        return list;

    }
    public void preOrder(TreeNode root,List<Integer> list){
        if(root==null){
            return;
        }
        list.add(root.val);
        preOrder(root.left,list);
        preOrder(root.right,list);
    }
}

//中序
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }

    void inorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inorder(root.left, list);
        list.add(root.val);             // 注意这一句
        inorder(root.right, list);
    }
}

//后序
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }

    void postorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        postorder(root.left, list);
        postorder(root.right, list);
        list.add(root.val);             
    }
}

遇到的问题

这道题容易出错的地方就是while循环的条件该不该带等于号，这种情况我一般会拿一组用例在自己脑子里过一遍。

假设{1,2,3}这组用例我们要找的target值是3，第一次循环的左下标是0，右下标是2，找到中间值是2比target值3小，所以我们将左下标调整为中间下标+1即为2，此时我们数组左右下标均为2，但目标值正好是下标2对应的值，所以应有left=right这个循环条件。

二叉树的迭代遍历

解题思路

迭代就是用栈这个数据结构去实现，其实递归底层也是使用栈。迭代比较有难度，要分为两种去讲

前/后序遍历

前序是中左右，那我们就每次循环就先将中加入到结果集，再按右左的顺序push到栈中，这样pop的时候顺序就是左右了，最后顺序就是中左右。

后序是左右中，那我们可以翻转一下就是中右左，所以我们只需要按前序的方法做好中右左顺序之后翻转即可。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            //先添加中，然后把右左入栈
            result.add(node.val);
            if (node.right != null){
                stack.push(node.right);
            }
            if (node.left != null){
                stack.push(node.left);
            }
        }
        return result;
    }  
}


class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            //先添加中，然后把左右入栈
            TreeNode node = stack.pop();
            res.add(node.val);
            if(node.left!=null){
                stack.push(node.left);
            }
            if(node.right!=null){
                stack.push(node.right);
            }
        }
        //最后翻转
        Collections.reverse(res);
        return res;
    } 
}

中序遍历

中序为什么要单独拿出来呢，因为我们拿到一个二叉树后首先拿到的是中节点，但是中序遍历要求我们先处理左节点，所以要调整一下。

这次我们要到最左下角的元素再处理，所以一直cur = cur.left，把每一个经过的都入栈。当cur.left为null说明左边没东西了，此时将该节点(也就是中节点)加入结果集，此时判断cur = cur.right然后继续遍历。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            //一路向左直到左节点为空，此时弹出一个元素加入结果集并开始处理它的右节点。
            if(cur!=null){
                stack.push(cur);
                cur = cur.left;
            }else{
                cur = stack.pop();
                res.add(cur.val);
                cur = cur.right;
            }
        }
        return res;
    }
}

二叉树的层序遍历

力扣题目链接

解题思路

这道题目是层序遍历，即为遍历元素和要处理的元素是同样的，所以我们需要一个先进先出的结构也就是队列，也进入的先处理。

代码示例

class Solution {

    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        level(root);
        return resList;
    }
    
    public void level(TreeNode node){
        if(node == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);
        while(!que.isEmpty()){
            //只要队列里还有东西，就一直循环
            
            //用来存储该层元素
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();
            //len代表该层有几个元素，为什么呢？ 
            //第一层进来len为1，然后offer进去左一个右一个。那第二层len为2，然后第一个节点又offer2个，第二个也是。
            //巧妙地让每次offer到队列里的是一层中的所有元素，然后不断poll()然后去新插入队列下一层的所有元素。
            while(len > 0){
                TreeNode temp = que.poll();
                itemList.add(temp.val);
                if(temp.left != null) que.offer(temp.left);
                if(temp.right != null) que.offer(temp.right);
                len--;
            }
            resList.add(itemList);
        }
    }
}