Day15-二叉树的前，中，后序遍历(递归/非递归)

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

前序遍历

/* 前序遍历二叉树
     * 1.先访问该节点:打印该节点的值
     * 2.再访问左子树：左子树访问完成的标志是左孩子访问完成，且它的左右孩子为null
     * 3.最后访问右子树：右子树访问完成的标志是左孩子访问完成，且它的左右孩子为null
     */

-递归实现

static void proOlder(TreeNode node){
        //1.终止条件
        if (node == null) return;
        //2.访问该节点
        System.out.print(node.value + " ");
        //3.访问左子树
        proOlder(node.left);
        //4.访问右子树
        proOlder(node.right);
    }

-非递归实现

static void proOlder2(TreeNode root){
        TreeNode curr = root;//表示当前节点
        Stack<TreeNode> stack = new Stack<>();//用于存储父节点
        //当前节点为空时：表示此节点不存在
        //当栈为空时，表示当前节点前的节点均遍历完成
        while (curr != null || !stack.isEmpty()){
            if (curr != null){
                //访问当前节点
                System.out.print(curr.value + " ");
                //将当前节点进行存储
                stack.push(curr);
                //访问左子树
                curr = curr.left;
            }else {//访问右子树
                TreeNode pop = stack.pop();
                curr = pop.right;
            }
        }
    }

中序遍历

/* 中序遍历二叉树
    * 1.访问左子树：左子树访问完成的标志是左孩子访问完成，且它的左右孩子为null
    * 2.先访问该节点:打印该节点的值
    * 3.访问右子树：右子树访问完成的标志是左孩子访问完成，且它的左右孩子为null
*/

-递归实现

static void inOlder(TreeNode node){
        //1.终止条件
        if (node == null) return;
        //2.访问左子树
        inOlder(node.left);
        //3.访问该节点
        System.out.print(node.value + " ");
        //4.访问右子树
        inOlder(node.right);
    }

-非递归实现

//非递归实现：
    static void inOlder2(TreeNode root){
        //curr:表示当前的节点
        TreeNode curr = root;
        //创建栈用于存储节点的父节点
        Stack<TreeNode> stack = new Stack<>();
        //当节点不为空时
        while (curr != null || !stack.isEmpty()){
            if (curr != null){//表示存在左节点
                //1.将当前节点进行存储
                stack.push(curr);
                //2.访问左子树:将当前节点表示为左孩子
                curr = curr.left;
            }else{//左节点遍历完成
                //3.访问右子树：
                TreeNode pop = stack.pop();//获得父节点
                System.out.print(pop.value + " ");
                curr = pop.right;
            }
        }
    }

后序遍历

/* 后序遍历二叉树
    * 1.访问左子树
    * 2.访问右子树
    * 3.访问此节点
    */

-递归实现

    static void postOlder(TreeNode node){
        //1.终止条件
        if (node == null) return;
        //2.访问左子树
        postOlder(node.left);
        //3.访问右子树
        postOlder(node.right);
        //4.访问该节点
        System.out.print(node.value + " ");
    }

-非递归实现

static void postOlder2(TreeNode node){
        //curr:表示当前的节点
        TreeNode curr = node;
        TreeNode pop = null;
        //创建栈用于存储节点的父节点
        Stack<TreeNode> stack = new Stack<>();
        //当节点不为空时
        while (curr != null || !stack.isEmpty()){
            if (curr != null){//表示存在左节点
                //1.将当前节点进行存储
                stack.push(curr);
                //2.访问左子树:将当前节点表示为左孩子
                curr = curr.left;
            }else{//左节点遍历完成
                //3.访问右子树：
                TreeNode peek = stack.peek();//获得父节点
                if (peek.right == null || peek.right == pop){//当父节点为空，则将此节点打印
                    pop = stack.pop();
                    System.out.print(pop.value + " ");
                }else{//将赋值于新节点
                    curr = peek.right;
                }
            }
        }
    }