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

二叉树理论⭐️

1.遍历方式

二叉树主要有两种遍历方式：

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。

• 深度优先遍历

  • 前序遍历（递归法，迭代法）
  • 中序遍历（递归法，迭代法）
  • 后序遍历（递归法，迭代法）

• 广度优先遍历

  • 层次遍历（迭代法）

• 如何实现遍历操作

  1. 之前我们讲栈与队列的时候，就说过栈其实就是递归的一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。

  2. 而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。

2. 存储方式

二叉树可以链式存储，也可以顺序存储。

那么链式存储方式就用指针， 顺序存储的方式就是用数组。

用数组来存储二叉树如何遍历的呢？

如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

3. 分类

1. 满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

2. 完全二叉树：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。

3. 二叉搜索树：前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。
   

4. 平衡二叉搜索树
   

递归三要素⭐️

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

1. 递归遍历

• 题目链接:代码随想录

• 解题思路：

  ①确定递归函数的参数和参数的返回值：
  因为要遍历所有的节点，所以要设置参数；
  因为要存储数据，所以设置申请一块存储空间存储遍历的数据
  ②遍历终止的条件：
  遍历的节点为null
  ③遍历的逻辑：
  先遍历根节点，然后遍历左节点，然后遍历右节点，最后返回存出结

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;
    }
}
public List<Integer> preorderTraversal(TreeNode root) {
    if(root == null){
        return list;
    }else{
        list.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);

        return list;
    }
}

2. 迭代遍历

题目链接:代码随想录

• 前序遍历非递归版
  解题思路：
  初始化现将根节点压入栈中；然后循环操作，每次弹出一个结点，压入两个结点，并且压入的顺序是先右再左，确保弹出栈的顺序是根左右。
  因为本题访问结点顺序，与处理结点（获得结果）的顺序一致，即访问结点即为根节点，所以解题格式较为对称

public List<Integer> preorderTraversal(TreeNode root) {
    if(root == null){
        return result;
    }

    Deque<TreeNode> deque = new ArrayDeque<>();
    deque.addFirst(root);

    while(!deque.isEmpty()){

        //弹出结点
        TreeNode temp = deque.removeFirst();
        result.add(temp.val);

        //压入右左节点
        if(temp.right != null){
            deque.addFirst(temp.right);
        }

        if(temp.left != null){
            deque.addFirst(temp.left);
        }

    }

    return result;
}

• 后序遍历解题思路：

  左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果

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

• 中序遍历思路：

  解题思路：
  在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。
  ①申请一个结点用于记录访问的节点
  ②对于访问节点是否为null，可以做出不同处理
  为null，说明已经遍历到头，那么弹出一个节点作为当前节点，处理它，然后处理其右边
  不为null，说明还没有遍历到头，压栈，然后继续访问这个节点的下一个节点
  

public List<Integer> inorderTraversal(TreeNode root) {
    if(root == null){
        return result;
    }
    Deque<TreeNode> deque = new LinkedList<>();

    TreeNode cur = root;//记录当前访问的元素，不一定是处理的元素
    while(cur != null || !deque.isEmpty()){
        //通过两个if语句，要决定对当前访问结点的操作
        if(cur != null){
            deque.addFirst(cur);//这才是进栈操作
            cur = cur.left;
        }else{
            //当前访问结点为空，那么弹出上一个结点，处理上一个结
            cur = deque.removeFirst();
            result.add(cur.val);
            cur = cur.right;//访问下一个结点
        }
    }
    return result;
}