day13 统一迭代法&&144. 二叉树的前序遍历&&145. 二叉树的后序遍历&&94. 二叉树的中序遍历

1.统一迭代法（Traversal 方法）
原理：使用栈和两个指针（cur 和 pre），cur 用于指向当前待处理节点，pre 记录最近一次弹出的节点。通过判断节点是否为空、有无右子树以及右子树是否处理完成等条件，在一个循环中统一实现三种遍历。
优势：提供了一种通用的迭代遍历框架，减少代码冗余，便于理解和维护不同遍历方式的实现逻辑。
//统一迭代法
public ListTraversal(TreeNode root){
List list = new ArrayList<>();
Stack stack = new Stack<>();
TreeNode cur = root;
TreeNode pre = null;//记录最近一次弹出结点
while(!stack.isEmpty()||cur != null){
if(cur != null){
stack.push(cur);
list.add(cur.val);//前序遍历时使用
//待处理左子树
cur = cur.left;
}else {
TreeNode peek = stack.peek();
if (peek.rightnull){//没有右子树
list.add(peek.val);//中后序时用
pre=stack.pop();
}else if (peek.rightpre){//右子树处理完成
pre=stack.pop();
list.add(pre.val);//后序时用
}else {//待处理右子树
list.add(peek.val);//中序时用
cur = peek.right;
}
}
}
return list;
}

2.前序遍历（preorderTraversal 方法）
递归实现（preOrder 方法）：先访问根节点，然后递归调用自身处理左子树和右子树，代码逻辑清晰，符合前序遍历的定义。
迭代实现：利用栈存储节点，先将根节点入栈，循环中不断弹出栈顶节点并访问，然后按右子节点、左子节点的顺序入栈，确保左子节点先被处理。
//144. 二叉树的前序遍历
public List preorderTraversal(TreeNode root) {
List list = new ArrayList<>();
//递归实现
// preOrder(root, list);
//非递归实现，迭代遍历
if (root == null) {
return list;
}
Stack stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
list.add(node.val);
if(node.right != null) {
stack.push(node.right);
}
if(node.left != null) {
stack.push(node.left);
}
}
return list;
}
private void preOrder(TreeNode root, List list) {
if (root == null) {
return ;
}
list.add(root.val);
preOrder(root.left, list);
preOrder(root.right, list);
}

3.后序遍历（postorderTraversal 方法）
递归实现（postorder 方法）：先递归处理左子树和右子树，最后访问根节点，遵循后序遍历的顺序。
迭代实现：通过栈模拟递归，入栈顺序为根 - 左 - 右，出栈顺序为根 - 右 - 左，最后对结果列表进行反转得到后序遍历结果。
//145. 二叉树的后序遍历
public List postorderTraversal(TreeNode root) {
List list = new ArrayList<>();
//递归实现
//postorder(root, list);
//非递归实现，迭代遍历 出栈顺序：中-右-左， 最后翻转结果
if (root == null) {
return list;
}
Stack stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
list.add(node.val);
if (node.left != null) {
stack.push(node.left);
}
if (node.right != null) {
stack.push(node.right);
}
}
Collections.reverse(list);
return list;
}
private void postorder(TreeNode root, List list) {
if (root == null) {
return ;
}
postorder(root.left, list);
postorder(root.right, list);
list.add(root.val);
}

4.中序遍历（inorderTraversal 方法）
递归实现（inorder 方法）：先递归处理左子树，接着访问根节点，最后递归处理右子树，体现中序遍历的顺序。
迭代实现：使用栈和 cur 指针，不断将左子节点入栈，直到左子节点为空，然后弹出节点访问并处理其右子树。
//94. 二叉树的中序遍历
public List inorderTraversal(TreeNode root) {
List list = new ArrayList<>();
//递归实现
//inorder(root, list);
//非递归实现，迭代遍历
if (root == null) {
return list;
}
Stack stack = new Stack<>();
TreeNode cur = root;
while (!stack.isEmpty()||cur!=null) {
if(cur!=null) {
stack.push(cur);
cur = cur.left;
}else {
cur = stack.pop();
list.add(cur.val);
cur = cur.right;
}
}
return list;
}
private void inorder(TreeNode root, List list) {
if (root == null) {
return ;
}
inorder(root.left, list);
list.add(root.val);
inorder(root.right, list);
}