二叉树的前后中序遍历——迭代和递归_二叉树中序遍历递归算法-优快云博客

六.二叉树

1. 二叉树的递归遍历

递归算法的学习_三要素

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

递归算法：前序遍历二叉树

顺序是中->左->右
函数的参数应该是一个指向结点的指针
终止条件是应该是指针指向的结点为null 也就是没有子结点了
单层递归的逻辑应该是先输出中结点，再让左结点进入递归函数，再让右结点进入递归函数

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

中序，后序。改变代码顺序即可

2. 二叉树迭代遍历（正常迭代法）

使用到了栈，根据规律处理

前序遍历顺序：中-左-右，入栈顺序：中-右-左

中序遍历顺序: 左-中-右入栈顺序：左-右

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

 //这里我使用了deque实现栈
Deque<Integer> deque = new ArrayDeque<Integer>();

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        Deque<TreeNode> stack_deque = new ArrayDeque<>();
        if(root == null){
            return result;
        }
        stack_deque.addFirst(root);
        while (!stack_deque.isEmpty()) {
            TreeNode node = stack_deque.removeFirst();
            result.add(node.val);
            if (node.right != null){
                stack_deque.addFirst(node.right);
            }
            if (node.left != null){
                stack_deque.addFirst(node.left);
            }
        }
        return result;
    }
}

中序不好理解最好在纸上画一下

在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素，前序和后序都是对取出来的同时进行处理和遍历

class Solution {
   public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        Deque<TreeNode> stack =new ArrayDeque<>();
        if (root == null){
            return result;
        }
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()){
            if (cur !=null){
                stack.addFirst(cur);
                cur = cur.left;
            }else {
                cur = stack.removeFirst();
                result.add(cur.val);
                cur=cur.right;
            }
        }
        return result;
    }
}

后序是在前序的基上调整代码然后再翻转list

在写代码时入栈的顺序是左右，出栈进list是中右左，一个reverse

最后结果刚好是左右中

class Solution {
     public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        Deque<TreeNode> stack = new ArrayDeque<>();
        if (root == null){
            return result;
        }
        stack.addFirst(root);
        while(!stack.isEmpty()){
            TreeNode cur = stack.removeFirst();
            result.add(cur.val);
            if (cur.left != null){
                stack.addFirst(cur.left);
            }
            if (cur.right != null){
                stack.addFirst(cur.right);
            }
        }
        Collections.reverse(result);
        return  result;
    }
}

3. 二叉树迭代遍历（统一迭代法）

通过空节点来标记

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 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);  // 添加右节点（空节点不入栈）
            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;
   }
}