二叉树的前序中序后序遍历

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作 依赖于具体的应用问题(比如：打印节点内容、节点内容加1)。 遍历是二叉树上最重要的操作之一，是二叉树上进 行其它运算之基础。

在遍历二叉树时，如果没有进行某种约定，每个人都按照自己的方式遍历，得出的结果就比较混乱，如果按照某种 规则进行约定，则每个人对于同一棵树的遍历结果肯定是相同的。

如果N代表根节点，L代表根节点的左子树，R代 表根节点的右子树，则根据遍历根节点的先后次序有以下遍历方式：

1. NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。（根左右）

2. LNR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。（左根右）

3. LRN：后序遍历(Postorder Traversal)——根的左子树--->根的右子树--->根节点。 由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根 的左子树和根的右子树。（左右根）

NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

二叉树的遍历：root为根节点，这里我们以List的方式存储二叉树的元素

一、前序遍历

①递归方式

public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer>list=new ArrayList<>();
        pre(root,list);
        return list;

    }
    public void pre(TreeNode root,List<Integer>list){
        if(root!=null){
            list.add(root.val);
            pre(root.left,list);
            pre(root.right,list);
        }
    }

②迭代方式

这里时利用了栈，注意入栈的顺序时先入右子树，再入左子树，这样才能保证，先出左子树，再出右子树

 public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer>list=new ArrayList<>();
        pre (root,list);
        return list;

    }
    public void pre(TreeNode root,List<Integer>list){
        if(root==null)return;
        Stack<TreeNode>stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur=stack.pop();
            list.add(cur.val);
            if(cur.right!=null){
                stack.push(cur.right);
            }
            if(cur.left!=null){
                stack.push(cur.left);
            }
        }
    }

二、中序遍历

①递归方式

 public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer>list=new ArrayList<>();
        ino(root,list);
        return list;
    }
    public void ino(TreeNode root,List<Integer>list){
        if(root!=null){
            ino(root.left,list);
            list.add(root.val);
            ino(root.right,list);
        }
    }

②迭代方式

public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer>list=new ArrayList<>();
        ino(root,list);
        return list;
    }
    public void ino(TreeNode root,List<Integer>list){
        if(root==null)return ;
        TreeNode cur=root;
        Stack<TreeNode>stack=new Stack<>();
        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;
            }
        }
    }

 三、后序遍历

①递归方法

 public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer>list=new ArrayList<>();
        pos(root,list);
        return list;

    }
    public void pos(TreeNode root,List<Integer>list){
        if(root!=null){
            pos(root.left,list);
            pos(root.right,list);
            list.add(root.val);
        }
    }

②迭代方法

因为后续遍历是按照左右根的方法进行遍历

所以遍历每个节点的时候都要判断左右是否已经遍历

pre就是用来判断右子树是否已经被遍历

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer>list=new ArrayList<>();
        pos(root,list);
        return list;
    }
    public void pos(TreeNode root,List<Integer>list){
        if(root==null){
            return;
        }
        Stack<TreeNode>stack=new Stack<>();
        TreeNode cur=root;
        TreeNode pre=null;
        while(cur!=null||!stack.isEmpty()){
            if(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }else{
                cur=stack.peek();
                if(cur.right==null||cur.right==pre){
                    list.add(cur.val);
                    stack.pop();
                    pre=cur;
                    cur=null;
                }else{
                    cur=cur.right;
                }
            }
        }
    }