二叉树的递归、非递归前中后序遍历和高度 JAVA

1 前中后序遍历

递归

/**
     * 递归的前中后
     */
    public static void preOrder(TreeNode node){
        System.out.println(node.val);
        if (node.left!=null){
            preOrder(node.left);
        }
        if (node.right!=null){
            preOrder(node.right);
        }

    }
    
    public static void midOrder(TreeNode node){
        if (node.left!=null){
            midOrder(node.left);
        }
        System.out.println(node.val);
        if (node.right!=null){
            midOrder(node.right);
        }
    }

    public static void backOrder(TreeNode node){
        if (node.left!=null){
            backOrder(node.left);
        }
        if (node.right!=null){
            backOrder(node.right);
        }
        System.out.println(node.val);
    }

非递归

/**
     * 前 非递归做
     * 
     */
    public static void preOrder_1(TreeNode node){
        Stack<TreeNode> stack = new Stack<>();
        while (node!=null||!stack.isEmpty()){
            while (node!=null){
                System.out.println(node.val);
                stack.push(node);
                node=node.left;
            }
            if (!stack.isEmpty()){
                node=stack.pop();
                node=node.right;
            }
        }
    }


    /**
     * 中 非递归
     */
    public static void midOrder1(TreeNode node){
        Stack<TreeNode> stack = new Stack<>();
        while (node!=null||!stack.isEmpty()){
            while (node!=null){
                stack.push(node);
                node=node.left;
            }
            if (!stack.isEmpty()){
                node = stack.pop();
                System.out.println(node.val);
                node = node.right;
            }
        }
    }


    /**
     * 后序  !!!
     */
    public static void postOrder(TreeNode biTree)
    {//后序遍历非递归实现
        int left = 1;//在辅助栈里表示左节点
        int right = 2;//在辅助栈里表示右节点
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<Integer> stack2 = new Stack<Integer>();//辅助栈，用来判断子节点返回父节点时处于左节点还是右节点。

        while(biTree != null || !stack.empty())
        {
            while(biTree != null)
            {//将节点压入栈1，并在栈2将节点标记为左节点
                stack.push(biTree);
                stack2.push(left);
                biTree = biTree.left;
            }

            while(!stack.empty() && stack2.peek() == right)
            {//如果是从右子节点返回父节点，则任务完成，将两个栈的栈顶弹出
                stack2.pop();
                System.out.println(stack.pop().val);
            }

            if(!stack.empty() && stack2.peek() == left)
            {//如果是从左子节点返回父节点，则将标记改为右子节点
                stack2.pop();
                stack2.push(right);
                biTree = stack.peek().right;
            }

        }
    }

2 层次遍历

/**
     * 层次遍历
     */
    public static void levelOrder(TreeNode node){
        if (node==null){
            return;
        }
        LinkedList<TreeNode> list = new LinkedList<>();
        list.add(node);
        TreeNode currentNode;
        while (!list.isEmpty()){
            currentNode = list.poll();
            System.out.println(currentNode.val);
            if (currentNode.left!=null){
                list.add(currentNode.left);
            }
            if (currentNode.right!=null){
                list.add(currentNode.right);
            }
        }
    }

3 树的高度

递归

    /**
     * 树的高度
     */
    public static int getHeight(TreeNode node){
        if (node==null){
            return 0;
        }
        int left = getHeight(node.left);
        int right = getHeight(node.right);
        return left>=right? left+1:right+1;
    }

非递归

/***
     * 非递归求解
     * @param root
     * @return
     */
    public int getTerrHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        //count 用来动态统计，每层有多少个节点。
        //nextCount 队列中保存的下一层的结点数目。
        //如果count++ = nextCount 就说明将该层遍历完了 deep++
        int deep = 0,count = 0,nextCount = 1;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){
            TreeNode treeNode = queue.poll();
            count ++;
            if(treeNode.left != null){
                queue.add(treeNode.left);
            }
            if(treeNode.right != null){
                queue.add(treeNode.right);
            }
            if(count == nextCount){
                nextCount = queue.size();
                count = 0;
                deep ++;
            }
        }
        return deep;
    }