代码随想录算法训练营Day12|递归遍历 、 迭代遍历 、统一迭代 、层序遍历

递归遍历 

        后序遍历：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        postorder(root, list);
        return list;
        
    }

    public void postorder(TreeNode cur, List list){
        if(cur == null){
            return;
        }
        postorder(cur.left, list);
        postorder(cur.right, list);
        list.add(cur.val);
    }
}

        前序遍历：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> l1= new ArrayList<>();
        preorder(root, l1);
        return l1;
    }

    public void preorder(TreeNode cur, List l1){
        if(cur == null){
            return;
        }
        l1.add(cur.val);
        preorder(cur.left, l1);
        preorder(cur.right, l1);
    }
}

        中序遍历：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        inorder(root,list);
        return list;
    }

    public void inorder(TreeNode cur, List list){
        if(cur == null){return;}
        inorder(cur.left, list);
        list.add(cur.val);
        inorder(cur.right,list);
    }
}

 迭代遍历 

代码框架：定义存结果的数组，如果根节点为空，直接返回。

定义一个栈，根节点入栈。

while循环：当节点不为空时，弹出栈顶元素存入临时变量，元素值入栈。右节点不为空时，右节点入栈；左节点不为空时，左节点入栈。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res= new ArrayList<>();
        if(root == null){
            return res;
        }
        Stack<TreeNode> st = new Stack<>();
        st.push(root);
        while(!st.isEmpty()){
            TreeNode temp = st.pop();
            res.add(temp.val);
            if(temp.right !=null){
                st.push(temp.right);
            }
            if(temp.left!=null){
                st.push(temp.left);
            }
        }
        //preorder(root, l1);
        return res;
    }

层序遍历

        图论中的广度优先遍历，用队列来实现。

        创建一个队列，将传入的根节点入队。当队列不为空时，记录当前队列的长度（首次只有头节点，长度为一）。当长度大于0时，遍历和长度相等数量的节点，每遍历一个，将其左右孩子节点入队。

        代码框架：创建返回结果的二维数组。创建队列，根节点入队。根节点为空直接返回。

while循环，队列不为空时，创建一个记录的当前层的一维数组。size记录当前层数量。

按照size数量遍历取出当前层的节点，取出一个就将其左右孩子节点入队，并且记录取出的元素。遍历完当前层后，把该一维数组加入二维数组中。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> D2List = new LinkedList<>();
        level(root, D2List);
        return D2List;
    }

    public void level(TreeNode root, List<List<Integer>> D2List){
        if(root == null){return;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new LinkedList<>();
            while(size-- > 0){
                TreeNode temp = queue.poll();
                list.add(temp.val);
                if(temp.left != null){
                    queue.add(temp.left);
                }
                if(temp.right != null){
                    queue.add(temp.right);
                }
            } 
            D2List.add(list);
        }
        return;
    }
}

 二叉树自底向上的层序遍历 

        思路：一样的思路，在把一维数组装入结果中时，用头插法即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        Level(root, res);
        return res;

    }

    public void Level(TreeNode root, List<List<Integer>> res){
        if(root == null){return;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new LinkedList<>();
            while(size-- > 0){
                TreeNode temp = queue.poll();
                list.add(temp.val);
                if(temp.left != null){
                    queue.add(temp.left);
                }
                if(temp.right != null){
                    queue.add(temp.right);
                }
            }
            res.addFirst(list);

        }
        return;
    }
}

199.二叉树的右视图

思路：遍历过程一样，只有当遍历到每一层的最后一个节点时，添加进结果集合。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        rightView(root, res);
        return res;
    }

    public void rightView(TreeNode cur, List<Integer> res){
        if(cur == null){return;}
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(cur);
        while(!que.isEmpty()){
            int size = que.size();
            while(size-- >0){
                TreeNode temp = que.poll();
                if(size == 0){
                    res.add(temp.val);
                }
                if(temp.left != null){
                    que.add(temp.left);
                }
                if(temp.right != null){
                    que.add(temp.right);
                }
            }
        }
        return;
    }
}

637.二叉树层的平均值

        思路：每一层加和，最后除以该层的长度。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> list = new ArrayList<>();
        if(root == null){return list;}
        Queue<TreeNode> que = new LinkedList<>();
        que.add(root);
        while(!que.isEmpty()){
            int size = que.size();
            int len = que.size();
            Double sum = 0.0;
            while(size-- > 0){
                TreeNode temp = que.poll();
                sum += temp.val;
                if(temp.left != null){
                    que.add(temp.left);
                }
                if(temp.right != null){
                    que.add(temp.right);
                }
            }
            list.add(sum / len);
        } 
        return list;
    }
}