二叉树的非递归遍历

       之所以想总结二叉树的非递归遍历，主要是因为在做《剑指offer》中“二叉树和双向链表”题目时，有递归方法和非递归方法，让我了解到我对二叉树的非递归遍历不熟悉，所以想着总结一下。

       经过自己实验这几种代码的编写，我最大的感受是，对于每一个节点，都要当成一颗二叉树来看待，不管它左右子树是否为空，当然不同情况要有不同的处理方法。

非递归中序代码（可运行）

       由于要在主函数种调用inOrderTraversal函数，而主函数是静态函数，所以inOrderTraversal也必须定义为静态函数，但如果你的使用场景中不是由静态函数调用，或其他不需要静态函数的场景，就不需要定义为静态函数。

      在这里是以打印顺序表示先序遍历的顺序，也可以将这些节点或节点的值按顺序放入一个容器中，取决于自己的应用场景。  

      解释见注释。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;

public class JustTry {
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5,6,7};
        TreeNode root = createTree(arr);
        InOrderTraversal(root);
        //preOrderTraversal(root);
        //postOrderTraversal(root);
       // postOrderTraversal1(root);

    }
    //从根节点开始，将节点及其左子树压入栈，直到一个左子树为空的节点，然后从栈中弹出节点，进行处理，因为节点的左
    //子树已经处理过了，所以只需要处理右子树就好了，把右子树当成一个根节点，再进行一次循环。
    public static void inOrderTraversal(TreeNode root){
        if(root == null){
            return;
        }
        TreeNode p = root;
        Stack<TreeNode> stack = new Stack<>();
        while(!stack.empty() || p != null){
            while (p != null){
                stack.push(p);
                p=p.left;
            }
            if(!stack.empty()){
                p = stack.pop();
                System.out.println(p.val);
                p=p.right;
            }
        }
    }

   
    //由数组创建一个二叉树，返回根节点
    public static TreeNode createTree(int[] arr) {
        if(arr==null || arr.length==0) {
            return null;
        }
        TreeNode[] treeArr = new TreeNode[arr.length];
        for(int i=0;i<arr.length;i++) {
            TreeNode Node = new TreeNode(arr[i]);
            treeArr[i] = Node;
        }

        for(int i=0;i<arr.length;i++) {
            if(2*i+1<arr.length) {
                treeArr[i].left = treeArr[2*i+1];
            }else {
                treeArr[i].left = null;
            }
            if(2*i+2<arr.length) {
                treeArr[i].right = treeArr[2*i+2];

            }else {
                treeArr[i].right = null;
            }
        }
        return treeArr[0];
    }
  
}

//二叉树节点定义
class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}

先序遍历代码

先序遍历和中序遍历的区别就是先序遍历在节点入栈前就进行处理，其他过程基本一致。

public static void preOrderTraversal(TreeNode root){
        if(root == null){
            return;
        }
        TreeNode p = root;
        Stack<TreeNode> stack = new Stack<>();
        while(!stack.empty() || p != null){
            while( p != null){
                System.out.println(p.val);
                stack.push(p);
                p=p.left;
            }
            if(!stack.empty()){
                p = stack.pop();
                p=p.right;
            }
        }
    }

后序遍历代码1

       逆先序遍历，https://leetcode-cn.com/官方给出的答案，先序遍历是中-左-右，假如先处理右孩子，则是中-右-左，之后将其逆序，就是左-右-中，即后续遍历。

public static void postOrderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);

        while(!stack.isEmpty()){
            TreeNode p = stack.pop();
            res.add(p.val);
            if(p.left != null){
                stack.push(p.left);
            }
            if(p.right != null){
                stack.push(p.right);
            }
        }
        Collections.reverse(res);
        for(int v:res){
            System.out.println(v);
        }
    }

后序遍历代码2

使用一个last标志，判断其右子树是否访问过或为空，若不为空其未访问过，先处理其右子树，否则处理这个节点。

public static void postOrderTraversal1(TreeNode root) {

        if(root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        TreeNode last = null;

        while(p != null || !stack.isEmpty()){
            while(p != null){
                stack.push(p);
                p = p.left;
            }
            p = stack.peek();
            if(p.right == null || p.right == last){
                System.out.println(p.val);
                stack.pop();
                last = p;
                p = null;
            }else{
                p = p.right;
            }
        }
    }