代码随想录day13

cookieeee_

已于 2024-08-07 17:44:25 修改

阅读量152

点赞数 1

文章标签：算法

于 2024-07-30 18:15:55 首次发布

本文链接：https://blog.csdn.net/cookieeee_/article/details/140803160

版权

第六章 二叉树part01

理论基础

文章讲解：代码随想录

递归遍历（必须掌握）

题目链接/文章讲解/视频讲解：代码随想录

迭代遍历（需强化）

题目链接/文章讲解/视频讲解：代码随想录

统一迭代（没跟）

题目链接/文章讲解：代码随想录

层序遍历

题目链接/文章讲解/视频讲解：代码随想录

理论基础

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

递归遍历（必须掌握）

144. 二叉树的前序遍历 - 力扣（LeetCode）

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

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

94. 二叉树的中序遍历 - 力扣（LeetCode）

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result=new ArrayList<Integer>();
        inorder(root,result);
        return result;
    }
    public void inorder(TreeNode root,List<Integer> result){
        if(root==null){
            return ;
        }
        inorder(root.left,result);
        result.add(root.val);
        inorder(root.right,result);
        
    }
}

145. 二叉树的后序遍历 - 力扣（LeetCode）

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);
        return result;
    }
    
    public void postorder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        
        postorder(root.left, result);
        postorder(root.right, result);
        result.add(root.val);
    }
    
}

迭代遍历(非递归遍历)

前序遍历

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> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        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();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        return result;
    }
}

后序遍历

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