二叉树深度，二叉树按层打印-java实现

版权声明：转载请标明附带连接标明出处 https://blog.csdn.net/Hollake/article/details/89322538

二叉树深度实现

  对于非递归实现如下：

首先，利用按层遍历的思想，设置level记录当前节点所在层数，再设置当前节点指针cur以及每层的节点总数last。在遍历    每层节点时，cur置零，遍历到cur = last时结束，level+1，继续遍历下一层。

  具体实现算法如下：

  二叉树数据结构

public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

二叉树深度递归实现：

如果一棵树只有一个结点，它的深度为1，如果根节点只有左子树而没有右子树，那么树的深度应该是其左子树的深度+1.同样如果根节点只有右子树而没有左子树，那么树的深度应该是其右子树+1.如果既有左子树又有右子树，那概述的深度就是左、右子树的深度的较大值加1.。利用这个思路，我们可以用递归来实现代码：

public static int cirTreeDepth(TreeNode root){
        if(root == null)
            return 0;
        int nLeft = cirTreeDepth(root.left);
        int nRight = cirTreeDepth(root.right);
        return (nLeft > nRight)?(nLeft+1):(nRight+1);
    }

二叉树深度非递归实现：

这里需要一个LinkedList集合来存放每层的节点，在刚开始，队列queue存放根节点root，只要queue中存在元素，那么说明二叉树还没有遍历完，所以在queue不为空时一直循环，在进行每层遍历时，只要当前遍历达到指针cur小于每层的节点总数，那么queue一直出一个元素，指针cur后移，接着如果如果左子树不为空添加到队列，//如果右子树不为空添加到队列尾部，每层循环遍历完，level++。

public int TreeDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        TreeNode  current;
        int cur,last;
        queue.add(root);
        int level = 0;
//      注意，这里不能是queue!=null因为queue在没有元素时本身这个对象是存在的，所以不可能为空
//      queue!=null 与 !queue.isEmpty()是两个概念，不能混淆
        while (!queue.isEmpty()) {
            last = queue.size();
            cur = 0;
            while (cur < last) {
                current = queue.pop();//出队列一个元素
                cur++;
                if (current.left != null) {//如果左子树不为空添加到队列
                    queue.add(current.left);
                }
                if (current.right != null) {//如果右子树不为空添加到队列
                    queue.add(current.right);
                }
            }
            level++;
        }
        return level;
    }

二叉树按层打印

思路和非递归的二叉树深度基本类似，按层遍历，在遍历每层时，初始化一个当前指针cur，一个当前层的元素的个数last，每遍历一个节点，使其出队列，添加到输出结果的list中，而且如果当前节点有子节点，那么添加子节点到队列尾部，当cur不满足小于last时，也就是遍历完当前层时，重置指针cur = 0，循环往复，一直到队列中没有元素，也就是遍历完所有层元素。

    public static ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if(root == null){
            return list;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        TreeNode current;
        int cur,last;
        queue.add(root);
        while(!queue.isEmpty()){
            cur = 0;
            last = queue.size();
            while(cur < last){
                current = queue.poll();
                list.add(current.val);
                cur++;
                if (current.left != null) {
                    queue.add(current.left);
                }
                if (current.right != null) {
                    queue.add(current.right);
                }
            }
        }
        return list;
    }

最终测试代码

测试代码二叉树按照下图构造：

package test;

import java.util.ArrayList;
import java.util.LinkedList;

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

public class MyTreeTest {
    public static void main(String[] args) {
        //初始化二叉树
        TreeNode root = MyTreeTest.init();
        System.out.println("非递归二叉树深度为");
        System.out.println(TreeDepth(root));
        System.out.println("递归二叉树深度为");
        System.out.println(cirTreeDepth(root));
        ArrayList<Integer> arrayList = PrintFromTopToBottom(root);
        System.out.println("二叉树按层打印顺序为");
        arrayList.forEach(System.out::print);
    }

    public static int cirTreeDepth(TreeNode root){
        if(root == null)
            return 0;
        int nLeft = cirTreeDepth(root.left);
        int nRight = cirTreeDepth(root.right);
        return (nLeft > nRight)?(nLeft+1):(nRight+1);
    }

    public static int TreeDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        TreeNode  current;
        int cur,last;
        queue.add(root);
        int level = 0;
        while (!queue.isEmpty()) {
            last = queue.size();
            cur = 0;
            while (cur < last) {
                current = queue.pop();//出队列一个元素
                cur++;
                if (current.left != null) {//如果左子树不为空添加到队列
                    queue.add(current.left);
                }
                if (current.right != null) {//如果右子树不为空添加到队列
                    queue.add(current.right);
                }
            }
            level++;
        }
        return level;
    }

    public static ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if(root == null){
            return list;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        TreeNode current;
        int cur,last;
        queue.add(root);
        while(!queue.isEmpty()){
            cur = 0;
            last = queue.size();
            while(cur < last){
                current = queue.poll();
                list.add(current.val);
                cur++;
                if (current.left != null) {
                    queue.add(current.left);
                }
                if (current.right != null) {
                    queue.add(current.right);
                }
            }
        }
        return list;
    }


    public static TreeNode init(){
        TreeNode A = new TreeNode(6);
        TreeNode B = new TreeNode(3);
        TreeNode C = new TreeNode(9);
        TreeNode D = new TreeNode(1);
        TreeNode E = new TreeNode(5);
        TreeNode F = new TreeNode(7);
        TreeNode G = new TreeNode(2);
        TreeNode H = new TreeNode(4);
        TreeNode I = new TreeNode(8);
        A.left = B;
        B.left = D;
        B.right = E;
        D.right = G;
        E.left = H;
        A.right = C;
        C.left = F;
        F.right = I;
        return A;
    }
}

测试结果：

非递归二叉树深度为
4
递归二叉树深度为
4
二叉树按层打印顺序为
639157248