代码随想录算法训练营第十四天 |递归遍历、迭代遍历

代码随想录算法训练营第十四天 |递归遍历、迭代遍历

---

其实还有个统一迭代，但是不想学了现在，hh，以后可以学习一下
今天还是补打卡，对这部分知识点进行温习了一遍，加深了理解，虽然并不是全理解，但是有收获
祝大家五一假期快乐！！！

---

题目链接：

先序遍历link
中序遍历link
后序遍历link

---

递归遍历

先序遍历、中序遍历、后序遍历

先序遍历：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        preorder(root,res); 
        return res;
    }

    public void preorder(TreeNode root,List<Integer> res) {
        //终止条件
        if(root==null)
            return;
        res.add(root.val);
        preorder(root.left,res);
        preorder(root.right,res);
    }
}

中序遍历：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
         List<Integer> res=new ArrayList<>();
        inorder(root,res);
        return res;
    }
    void inorder(TreeNode root,List<Integer> res) {
        if(root==null)
            return;

        inorder(root.left,res);
        res.add(root.val);
        inorder(root.right,res);
    }
}

后序遍历：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        postorder(root,res);
        return res;
    }
    void postorder(TreeNode root,List<Integer> res) {
        if(root==null)
            return;

        postorder(root.left,res);
        postorder(root.right,res);
        res.add(root.val);
    }
}

---

迭代遍历

思路：使用栈进行遍历
栈的特性是：先进后出！！！非常重要

先序遍历：先把根节点放入栈中，再取出，然后放入右子树，再左子树（因为栈的特性：后进先出）

后序遍历：先把根节点放入栈中，然后出栈，再放入左节点，最后放入右节点，出栈的效果是 中，右，左，然后数组进行反转就变成了左右中，即为后序遍历
使用Collections.reverse()函数进行List反转

中序遍历：先设置一个临时节点cur，循环内之只要是当前节点不为空，继续遍历cur的左节点，若cur为空，则把栈中的元素取出放入List数组中，然后遍历cur的右节点
推荐视频：代码随想录

先序遍历：

class Solution {
    public List<Integer> preorderTraversal(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.right != null) {
                stack.push(node.right);
            }
            if(node.left!=null) {
                stack.push(node.left);
            }
        }
        return res;
    }
}

后序遍历：

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;
    }
}

中序遍历：

lass Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        if(root==null)
            return res;
        //中序遍历：先设置一个临时节点cur，循环内之只要是当前节点不为空，继续遍历cur的左节点，若cur为空，则把栈中的元素取出放入List数组中，然后遍历cur的右节点
        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;
    }
}

祝大家假期快乐😊😊😊
感谢观看。