Day14_二叉树：● 理论基础 ●前序遍历 ● 中序遍历 ● 后序遍历

二叉树理论基础

• 二叉树的定义，代码很重要

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

• 二叉树的存储方式：既可以使用指针链式存储，也可以以数组的形式顺序存储；
• 对于前中后序的遍历，只需要记住中间节点的位置即可；

对于深度优先遍历，既有递归法，也有迭代法。迭代法一般就是自己手动实现栈的逻辑，去遍历。这里对二叉树的前中后序遍历的递归法和迭代法做一个总结和分享：

前序遍历：中左右

• 递归实现

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) {
        if (root == null) {
            return;
        }
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

• 迭代实现
  

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;

        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                res.add(node.val);//处理当前节点
                stack.push(node);//将当前节点压入栈中
                node = node.left;//移动到左子节点
            }
            node = stack.pop();//从栈中弹出一个节点
            node = node.right;//移动到右子节点
        }
        return res;
    }
}

中序遍历：左中右

• 递归实现

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

    public 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> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();

        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
            root = stk.pop();
            res.add(root.val);
            root = root.right;
        }
        return res;
    }
}

后序遍历：左右中

• 递归法

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> res) {
        if (root == null) {
            return;
        }
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

• 迭代法

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

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode prev = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }
}