代码随想录训练营day14

最新推荐文章于 2023-02-17 21:57:23 发布

JIUYU_M

最新推荐文章于 2023-02-17 21:57:23 发布

阅读量2.5k

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/weixin_45977348/article/details/127164442

版权

题目一：二叉树的递归遍历

力扣题目链接：前序、中序、后序

题目描述：给你二叉树的根节点 root ，返回它节点值的 前序、中序、后序 遍历。

思路分析：（来自代码随想录）

按照递归三要素即可写出递归算法

确定递归函数的参数和返回值
确定终止条件
确定单层递归的逻辑

前序遍历：


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

    public void preorder(TreeNode root, List<Integer> res) { // 1、确定参数和返回值
        if (root == null) { // 2、确定终止条件
            return;
        }
        // 3、确定单层递归的逻辑
        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<Integer>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode cur, List<Integer> list) { // 1、确定参数和返回值
        if (cur == null) { // 2、确定终止条件
            return;
        }
        // 3、确定单层递归的逻辑
        inorder(cur.left, list);
        list.add(cur.val);
        inorder(cur.right, list);
    }
}

后序遍历：


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

    public void postorder(TreeNode root, List<Integer> list) { // 1、确定参数和返回值
        if (root == null) { // 2、确定终止条件
            return;
        }
        // 3、确定单层递归的逻辑
        postorder(root.left, list);
        postorder(root.right, list);
        list.add(root.val);
    }
}

题目二：二叉树的迭代遍历

题目描述：给你二叉树的根节点 root ，返回它节点值的 前序、中序、后序 遍历。

思路分析：栈解决（详情见代码随想录）

处理：将元素放进result数组中
访问：遍历节点

前序遍历：


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

题目三：二叉树的统一迭代法

题目描述：给你二叉树的根节点 root ，返回它节点值的 前序、中序、后序 遍历。

思路分析：标记法（没深入理解，详情见代码随想录）

将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。

前序遍历：


class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> st = new Stack<>();
        if (root != null) st.push(root);
        while (!st.empty()) {
            TreeNode node = st.peek();
            if (node != null) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
                if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）
                st.push(node);                          // 添加中节点
                st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
                
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.peek();    // 重新取出栈中元素
                st.pop();
                result.add(node.val); // 加入到结果集
            }
        }
        return result;
    }
}

中序遍历：


class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Stack<TreeNode> st = new Stack<>();
        if (root != null) st.push(root);
        while (!st.isEmpty()) {
            TreeNode node = st.peek();
            if (node != null) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
                st.push(node);                          // 添加中节点
                st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.peek();    // 重新取出栈中元素
                st.pop();
                result.add(node.val); // 加入到结果集
            }
        }
        return result;
    }
}

后序遍历：


 // 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {
   public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> st = new Stack<>();
        if (root != null) st.push(root);
        while (!st.empty()) {
            TreeNode node = st.peek();
            if (node != null) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                st.push(node);                          // 添加中节点
                st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
                if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
                if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）         
                               
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.peek();    // 重新取出栈中元素
                st.pop();
                result.add(node.val); // 加入到结果集
            }
        }
        return result;
   }
}