二叉树的前中后序遍历（递归与非递归）

    /**
     * BST树的节点类型
     * @param <T>
     */
    class BSTNode <T extends Comparable<T>>{
        private T data; // 数据域
        private BSTNode<T> left; // 左孩子域
        private BSTNode<T> right; // 右孩子域
    
        public BSTNode(T data, BSTNode<T> left, BSTNode<T> right) {
            this.data = data;
            this.left = left;
            this.right = right;
        }
    
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        public BSTNode<T> getLeft() {
            return left;
        }
    
        public void setLeft(BSTNode<T> left) {
            this.left = left;
        }
    
        public BSTNode<T> getRight() {
            return right;
        }
    
        public void setRight(BSTNode<T> right) {
            this.right = right;
        }
    }
    
    /**
     * BST树的实现
     * @param <T>
     */
    class BST<T extends Comparable<T>>{
        private BSTNode<T> root; // 指向根节点
    
        /**
         * BST树的初始化
         */
        public BST() {
            this.root = null;
        }
    
    /**
         * 二叉树的前序遍历（非递归）
         */
        public void perOrder(){
            Stack<BSTNode> stack = new Stack<>();
            while (this.root != null|| !stack.isEmpty()){//当根节点不为null 或者 栈里面不为空的
                while (root!=null){
                    System.out.print(root.getData()+"  ");
                    stack.push(root);
                    root = root.getLeft();
                }
                if (!stack.isEmpty()){// 这是剩下最后的叶子节点将其答应出来
                    root = stack.pop();
                    root = root.getRight();
                }
            }
        }
    
        /**
         * 前序递归实现
         */
        public void perOrderRe(){
            System.out.println();
            System.out.print("前序递归遍历：");
            PerOrderRe(this.root);
            System.out.println();
        }
    
        private void PerOrderRe(BSTNode<T> root) {
            if (root == null){
                return;
            }
            System.out.print(root.getData()+"  ");
            PerOrderRe(root.getLeft());
            PerOrderRe(root.getRight());
        }
    
        /**
         * 二叉树的中序遍历（非递归）
         */
        public void midOrder(){
            Stack<BSTNode> stack = new Stack<>();
            while (root!= null||!stack.isEmpty()){
                while (root!=null){
                    stack.push(root);
                    root = root.getLeft();
                }
                if (!stack.isEmpty()){
                    root = stack.pop();
                    System.out.print(root.getData()+"  ");
                    root = root.getRight();
                }
            }
        }
    
        /**
         * 中序遍历的递归实现
         */
        public void midOrderRe(){
            System.out.print("递归中序遍历:");
            MIDOrderRe(root);
            System.out.println();
        }
    
        private void MIDOrderRe(BSTNode<T> root) {
            if (root == null){
                return;
            }
            MIDOrderRe(root.getLeft());
            System.out.print(root.getData()+"  ");
            MIDOrderRe(root.getRight());
        }
    
        /**
         * 二叉树的后序遍历（非递归）
         */
        public void postOrder(){
            int left = 1 ,right = 2;
            Stack<BSTNode> stack1 = new Stack<>();
            Stack<Integer> stack2 = new Stack<>();
    
            while (root != null||!stack1.isEmpty()){
                while (root != null){
                    stack1.push(root);
                    stack2.push(left);
                    root = root.getLeft();
                }
                while (!stack1.empty() && stack2.peek()==right){
                    stack2.pop();
                    System.out.print(stack1.pop().getData()+"  ");
                }
                if (!stack1.empty()&&stack2.peek()==left){
                    stack2.pop();
                    stack2.push(right);
                    root = stack1.peek().getRight();
                }
            }
        }
    
        /**
         * 二叉树的后续遍历  递归法
         */
        public void postOrderRe(){
            System.out.print("递归后序遍历：");
            PostOrderRe(root);
        }
        private void PostOrderRe(BSTNode<T> root) {
            if (root == null){
                return;
            }
            PostOrderRe(root.getLeft());
            PostOrderRe(root.getRight());
            System.out.print(root.getData()+"  ");
        }
 }