二叉树的前、中、后序遍历（迭代法）

前序遍历

中、左、右

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList();
    if(root == null) return res;
    Deque<TreeNode> stack = new ArrayDeque();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        res.add(node.val);
        if (node.right != null) stack.push(node.right);
        if (node.left != null) stack.push(node.left);
    }
    return res;
}

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList();
    if(root == null) return res;
    Stack<TreeNode> stack = new Stack();

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

中序遍历

左、中、右

public List<Integer> inorderTraversal(TreeNode node) {
    List<Integer> res = new ArrayList();
    if (node == null) return res;
    Stack<TreeNode> stack = new Stack();
    while (node != null || !stack.isEmpty()) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        res.add(node.val);
        node = node.right;
    }
    return res;
}

后序遍历

左、右、中
后序遍历稍微复杂

迭代写法，利用pre记录上一个访问过的结点，与当前结点比较，如果是当前结点的子节点，说明其左右结点均已访问，将当前结点出栈，更新pre记录的对象。

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList();
    Deque<TreeNode> stack = new ArrayDeque();
    TreeNode pre = null;

    while(!stack.isEmpty() || root != null) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
        TreeNode node = stack.pop();
        if (node.right != null && node.right != pre) {
        	// node.right != null 说明 右子树不为空 
        	// node.right != pre  说明 右子节点还没访问过
        	// 综合两个就是 应该先去访问右子树
            root = node.right;
            stack.push(node);
        }else{
            res.add(node.val);
            pre = node;
        }
    }
    return res;
}

public List<Integer> postorderTraversal(TreeNode root) {
      List<Integer> list = new ArrayList();
      if (root == null) return list;
      Stack<TreeNode> stack = new Stack();
      stack.push(root);
      TreeNode prev = null; // prev变量跟踪上一次访问的节点
      while (!stack.isEmpty()){
          TreeNode node = stack.peek();

          if (prev == null || prev.left == node || prev.right == node){
              // 如果上一个访问的节点是当前结点的父节点，说明正在向下遍历树


              if (node.left != null) // 如果左孩子存在 左孩子入栈
                  stack.push(node.left);
              else if (node.right != null) // 左孩子没有，右孩子存在，右孩子入栈
                  stack.push(node.right);
              else{    //没有子树，则出栈，
                  list.add(node.val);
                  stack.pop();
              }
          }else if (node.left == prev){
              // 如果上一个节点是当前结点的左孩子，说明在从左子树向上遍历

              if (node.right != null)
                  stack.push(node.right); //如果有右孩子，则右孩子入栈
              else{  // 没有右孩子 则当前结点出栈
                  list.add(node.val);
                  stack.pop();                
              } 
          }else if (node.right == prev){
              // 如果上一个节点是当前结点右子树，说明在从右子树向上遍历
              // 直接出栈
              list.add(node.val);
              stack.pop();               
          }
          prev = node;
      }
      return list;
  }

取巧的方法。该写法的访问顺序并不是后序遍历，而是利用先序遍历“根左右”的遍历顺序，将先序遍历顺序更改为“根右左”，反转结果List，得到结果顺序为“左右根”

1 可以看做前序遍历的逆序 只不过是中、右、左顺序的前序遍历

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> res = new LinkedList();
    if (root == null) return res;
    Stack<TreeNode> stack = new Stack();
    stack.push(root);

    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        if (node.left != null) stack.push(node.left);
        if (node.right != null) stack.push(node.right);
        res.add(0, node.val);
    }
    return res;
}