二叉树的各种算法面试题及答案解析，被大佬问到自闭

public class TreeNode {

    int val = 0;

    TreeNode left = null;

    TreeNode right = null;



    public TreeNode(int val) {

        this.val = val;

    }

} 

计算树的结点数量（递归）

树的结点数量等于左子树加上右字数的数量+1

public class Solution {

    public int sumOfNode(TreeNode root) {

        if(root==null){

            return 0;

        }

         int leftSum=sumOfNode(root.left);

         int rightSum=sumOfNode(root.right);

         return leftSum+rightSum+1;

    }

} 

计算树的结点数量（非递归）

使用队列，取出上层结点的同时，将下层左右子节点存入

public class Solution {

    public int sumOfNode(TreeNode root) {

        if(root==null){

            return 0;

        }

         Queue<TreeNode> queue=new LinkedList<TreeNode>();

         queue.offer(root);

         int sum=0；

         while(!queue.isEmpty()){

			TreeNode node=queue.poll();

			sum++;

			if(node.left!=null){

				queue.offer(node.left);

			}

			if(node.right!=null){

				queue.offer(node.right);

			}

		}

         return sum;

    }

} 

树的深度计算（非递归）

import java.util.Queue;

import java.util.LinkedList;

public class Solution {

    public int TreeDepth(TreeNode root) {

        if(root==null){

            return 0;

        }

        if(root.left==null&&root.right==null){

            return 1;

        }

        int currentLevelNodes=1;     //记录当前层的结点数量

        int nextLevelNodes=0;          //记录下一层结点的数量

        int depth=0;                  //记录树的深度

        Queue<TreeNode> queue=new LinkedList<TreeNode>();

        queue.offer(root);

        while(!queue.isEmpty()){

            TreeNode node=queue.poll();        //取出一个结点，记录该结点的下一层结点，这也是queue的使用原因

            currentLevelNodes--;

            if(node.left!=null){

                queue.offer(node.left);

                nextLevelNodes++;

            }

            if(node.right!=null){

                queue.offer(node.right);

                nextLevelNodes++;

            }

            if(currentLevelNodes==0){

                currentLevelNodes=nextLevelNodes;

                nextLevelNodes=0;

                depth++;

            }

            

        }

        return depth;

    }

} 

树的深度计算（递归）

public class Solution {

    public int TreeDepth(TreeNode root) {

        if(root==null){

            return 0;

        }

        if(root.left==null&&root.right==null){

            return 1;

        }

        int leftLength=TreeDepth(root.left);

        int rightLength=TreeDepth(root.right);

        return Math.max(leftLength,rightLength)+1;

    }

} 

从上向下遍历树

记得使用队列 Queue！！

import java.util.Queue;

import java.util.LinkedList;

public class Solution {

    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {

        ArrayList<Integer> array=new ArrayList<Integer>();

        if(root==null){

            return array;

        }

         Queue<TreeNode> queue=new LinkedList<TreeNode>();

        queue.offer(root);

        while(!queue.isEmpty()){

            TreeNode node=queue.poll();

            if(node.left!=null){

                queue.offer(node.left);

            }

            if(node.right!=null){

                queue.offer(node.right);

            }

            array.add(node.val);

        }

        return array;

    }

} 

前序遍历（递归）

这里的陷阱在于ArrayList<Integer> array=new ArrayList<Integer>()；变量array的使用

import java.util.ArrayList;

public class Solution {

    public ArrayList<Integer> preorderTraversal(TreeNode root) {

        ArrayList<Integer> array=new ArrayList<Integer>();

        if(root==null){

            return array;

        }

        preorderTraversal(root,array);

        return array;

    }

    public void preorderTraversal(TreeNode root,ArrayList<Integer> array){

        if(root==null){

            return;

        }

        array.add(root.val);

        preorderTraversal(root.left,array);

        preorderTraversal(root.right,array);

    }

} 

前序遍历（非递归）

使用栈，对于每一个结点来说，先将它的右节点放进去，再将左节点放进去，然后循环拿出栈顶元素，这样可以做到执行完所有的左子树才能轮上右子树。

import java.util.ArrayList;

import java.util.Stack;

public class Solution {

    public ArrayList<Integer> preorderTraversal(TreeNode root) {

        ArrayList<Integer> array=new ArrayList<Integer>();

        if(root==null){

            return array;

        }

        Stack<TreeNode> stack=new Stack<TreeNode>();

        stack.push(root);

        while(!stack.isEmpty()){

            TreeNode node=stack.pop();

            array.add(node.val);

            if(node.right!=null){

                stack.push(node.right);

            }

            if(node.left!=null){

                stack.push(node.left);

            }

        }

        return array;

    }

} 

中序遍历（递归）

这里的陷阱在于ArrayList<Integer> array=new ArrayList<Integer>()；变量array的使用

import java.util.ArrayList;

public class Solution {

    public ArrayList<Integer> inorderTraversal(TreeNode root) {

        ArrayList<Integer> array=new ArrayList<Integer>();

        if(root==null){

            return array;


# 最后

我想问下大家当初选择做程序员的初衷是什么？有思考过这个问题吗？高薪？热爱？

既然入了这行就应该知道，这个行业是靠本事吃饭的，你想要拿高薪没有问题，请好好磨练自己的技术，不要抱怨。有的人通过培训可以让自己成长，有些人可以通过自律强大的自学能力成长，如果你两者都不占，还怎么拿高薪？

架构师是很多程序员的职业目标，一个好的架构师是不愁所谓的35岁高龄门槛的，到了那个时候，照样大把的企业挖他。为什么很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。

如果你也想成为一名好的架构师，那或许这份**Java核心架构笔记**你需要阅读阅读，希望能够对你的职业发展有所帮助。

**[CodeChina开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频】](https://codechina.csdn.net/m0_60958482/java-p7)**

**中高级开发必知必会：**

# 最后

我想问下大家当初选择做程序员的初衷是什么？有思考过这个问题吗？高薪？热爱？

既然入了这行就应该知道，这个行业是靠本事吃饭的，你想要拿高薪没有问题，请好好磨练自己的技术，不要抱怨。有的人通过培训可以让自己成长，有些人可以通过自律强大的自学能力成长，如果你两者都不占，还怎么拿高薪？

架构师是很多程序员的职业目标，一个好的架构师是不愁所谓的35岁高龄门槛的，到了那个时候，照样大把的企业挖他。为什么很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。

如果你也想成为一名好的架构师，那或许这份**Java核心架构笔记**你需要阅读阅读，希望能够对你的职业发展有所帮助。

**[CodeChina开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频】](https://codechina.csdn.net/m0_60958482/java-p7)**

**中高级开发必知必会：**

![](https://img-blog.csdnimg.cn/img_convert/039a1385e628ae04216c9d1df73d1863.png)