树的遍历Java实现

class SearchTree{
    /**
     * 递归中序遍历
     * @return
     */
    ArrayList<Integer> resInorder = new ArrayList<>();
    public ArrayList<Integer> inorderTree(TreeNode treeNode){
        if (treeNode == null)
            return this.resInorder;
        inorderTree1(treeNode);
        return this.resInorder;
    }
    public void inorderTree1(TreeNode treeNode){
        if (treeNode == null){
            return ;
        }
        inorderTree(treeNode.left);
        this.resInorder.add(treeNode.val);
        inorderTree(treeNode.right);
    }
    /**
     * 非递归中序遍历
     */
    public ArrayList<Integer> inorderTraversal(TreeNode treeNode){
        if (treeNode == null){
            return this.resInorder;
        }
        Stack<TreeNode> treeNodes = new Stack<TreeNode>();
        treeNodes.push(treeNode);
        while (!treeNodes.isEmpty()){
            TreeNode treeNodeTemp = treeNodes.peek();
            if (treeNodeTemp.left == null){
                TreeNode p = treeNodes.pop();//根节点出栈
                resInorder.add(p.val);
                if (p.right != null){
                    treeNodes.push(p.right);//右子树节点入栈
                }
            }else{
                //左子树不等于空的情况下根节点右子树也不一定为空，此时无需把根节点出栈
                treeNodes.push(treeNodeTemp.left);
                //为避免循环遍历根节点的左子树，需要把根节点左子树置空
                treeNodeTemp.left = null;
            }
        }
        return resInorder;
    }

    ArrayList<Integer> resPreorder = new ArrayList<>();
    /**
     * 非递归前序遍历
     */
    public ArrayList<Integer> preorder(TreeNode treeNode){
        if (treeNode == null){
            return resPreorder;
        }
        Stack<TreeNode> treeNodes = new Stack<TreeNode>();
        treeNodes.push(treeNode);
        while (!treeNodes.isEmpty()){
            TreeNode p = treeNodes.peek();
            resPreorder.add(p.val);
            treeNodes.pop();
            if (p.right != null){
                treeNodes.push(p.right);
            }
            if (p.left == null){
                //左子树等于空，遍历右子树
            }else{//先遍历左子树，再遍历右子树

                treeNodes.push(p.left);
            }
        }
        return  resPreorder;
    }

    /**
     * 非递归后续遍历
     */
    ArrayList<Integer> resPostorder = new ArrayList<>();
    public ArrayList<Integer> postorder(TreeNode treeNode){
        if (treeNode == null){
            return resPostorder;
        }
        Stack<TreeNode> treeNodes = new Stack<>();
        treeNodes.push(treeNode);
        while (!treeNodes.isEmpty()){
            TreeNode p = treeNodes.peek();
            if (p.right == null && p.left == null){
                treeNodes.pop();
                resPostorder.add(p.val);
            }
            if (p.right != null){
                treeNodes.push(p.right);
                p.right = null;
            }
            if (p.left != null){
                treeNodes.push(p.left);
                p.left = null;

            }
        }
        return this.resPostorder;
    }