二叉树:大厂面试必会的二叉树知识点!

二叉树

    • LeetCode104:二叉树的最大深度
    • 解题思路
    • 代码实现
    • LeetCode102:二叉树的层次遍历
    • 解题思路
    • 代码实现
    • LeetCode98:验证二叉搜索树
    • 解题思路
    • 代码实现
    • LeetCode700:二叉搜索树中的搜索
    • 解题思路
    • 代码实现
    • LeetCode450:二叉搜索树中的删除
    • 解题思路
    • 代码实现
    • LeetCode110:平衡二叉树
    • 解题思路
    • 代码实现
    • LeetCode222:完全二叉树的节点个数
    • 解题思路
    • 代码实现
    • LeetCode814:二叉树的剪枝
    • 解题思路
    • 代码实现
    • 剑指offer40:最小的k个数
    • 解题思路
    • 代码实现
    • 剑指offer7:重建二叉树
    • 解题思路
    • 代码实现
    • 剑指offer37:序列化二叉树
    • 解题思路
    • 代码实现
    • 剑指offer34:二叉树中和为某一值的路径
    • 解题思路
    • 代码实现
    • 总结

不要纠结,干就完事了,熟练度很重要!!!多练习,多总结!!!

LeetCode104:二叉树的最大深度

给定一个二叉树,找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

解题思路

其经典解法是递归操作!maxDepth(root) = max(maxDepth(root.left), maxDepth(root.right)) + 1没有什么多余的复杂操作,就是这么一行经典代码!但是这里面用到的思想则是类似DFS(深度优先搜索算法),这个也是要求掌握的,下面会一并给出!

代码实现

class Solution {
     
    public int maxDepth(TreeNode root) {
     
        if (root==null){
     
            return 0;
        }
        int left=maxDepth(root.left);
        int right=maxDepth(root.right);
        return Math.max(left,right)+1;
    }
}

二叉树的DFS实现,很重要希望你能掌握!

private List<TreeNode> traversal(TreeNode root) {
     
     List<TreeNode> res = new ArrayList<>();
     Stack<TreeNode> stack = new Stack<>();
     stack.add(root);
     while (!stack.empty()) {
     
         TreeNode node = stack.peek();
         res.add(node);
         stack.pop();
        if (node.right != null) {
     
            stack.push(node.right);
        }
        if (node.left != null) {
     
            stack.push(node.left);
        }
    }
    return res;
}

LeetCode102:二叉树的层次遍历

给定一个二叉树,返回其按层次遍历的节点值。(即逐层地,从左到右访问所有节点)。

例如:
给定二叉树: [3,9,20,null,null,15,7],

3
/ \

9 20

/ \

15 7
返回其层次遍历结果:[[3],[9,20],[15,7]]

解题思路

二叉树的层次遍历,经典的BFS方法,借助队列来实现!你同样要掌握的哦!再次声明,二叉树的DFS和BFS一定要会!

代码实现

class Solution {
     
    public List<List<Integer>> levelOrder(TreeNode root) {
     
        List<List<Integer>> res=new ArrayList<>();
        if (root==null){
     
            return res;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){
     
            int queuesize=queue.size();
            List<Integer> tmp=new ArrayList<>();
            for (int i=0;i<queuesize;i++){
     
                TreeNode node=queue.remove();
                tmp.add(node.val);
                if (node.left!=null){
     
                    queue.add(node.left);
                }
                if (node.right!=null){
     
                    queue.add(node.right);
                }
            }
            res.add(new ArrayList<>(tmp));
        }
        return res;
    }
}

LeetCode98:验证二叉搜索树

给定一个二叉树,判断其是否是一个有效的二叉搜索树。

解题思路

首先你要明白二叉搜索树的定义。
二叉搜索树(Binary Search Tree),(又:二叉查找树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树:若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值;若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值;它的左、右子树也分别为二叉搜索树。
是的,不只是满足当前节点的只值大于左子节点的值,更是要整个左子树的值都小于当前节点的值,右子树也是如此!那么开始时,我们需要初始化两个值min和max,对 我们选用long型的MIN_VALUE和MAX_VALUE,然后进行递归求解,每次我们遍历到一个节点,看当前节点是否满足,该节点值大于左子节点并且小于右子节点,不满足返回false,满足那么还需验证该节点的左、右子树是否也满足这个条件

代码实现

class Solution {
     
    public boolean isValidBST(TreeNode root) {
     
        if (root==null){
     
            return true;
        }
        return isBST(root,Long.MIN_VALUE,Long.MAX_VALUE);
    }
    public boolean isBST(TreeNode root,long min,long max){
     
        if (root==null){
     
            return true;
        }
        if (min>=root.val||max<=root.val){
     
            return false;
        }
        return isBST(root.left,min,root.val)&&isBST(root.right,root.val,max);
    }
}

LeetCode700:二叉搜索树中的搜索

给定二叉搜索树(BST)的根节点和一个值。你需要在BST中找到节点值等于给定值的节点。返回以该节点为根的子树。如果节点不存在,则返回 NULL。

解题思路

上面我们了解了二叉搜索树的概念,那么要查找一个节点,我们按照BST的特性即可,即对比查找的值与当前节点值的大小,小于则在左子树中寻找,大于则在右子树中寻找,要么中途找到返回节点,要么遍历到根节点返回null

代码实现

class Solution {
     
    public TreeNode searchBST(TreeNode root, int val) {
     
        while (root!=null){
     
            if (root.val==val){
     
                return root;
            }else if (root.val<val){
     
                root=root.right;
            }else {
     
                root=root.left;
            }
        }
        return null;
    }
}

LeetCode450:二叉搜索树中的删除

给定一个二叉搜索树的根节点 root 和一个值 key,删除二叉搜索树中的 key 对应的节点,并保证二叉搜索树的性质不变。返回二叉搜索树(有可能被更新)的根节点的引用。

一般来说,删除节点可分为两个步骤:
首先找到需要删除的节点;
如果找到了,删除它。
说明:要求算法时间复杂度为 O(h),h 为树的高度。

解题思路

我们要删除BST的一个节点,首先需要找到该节点。而找到之后,会出现三种情况。

1.待删除的节点左子树为空,让待删除节点的右子树替代自己。
2.待删除的节点右子树为空,让待删除节点的左子树替代自己。
3.如果待删除的节点的左右子树都不为空。我们需要找到比当前节点小的最大节点(前驱),来替换自己或者比当前节点大的最小节点(后继),来替换自己。

代码实现

class Solution {
     
    public TreeNode deleteNode(TreeNode root, int key) {
     
        if (root==null){
     
            return null;
        }
        if (key<root.val){
     
            root.left=deleteNode(root.left,key);
            return root;
        }
        if (key>root.val){
     
            root.right=deleteNode(root.right,key);
            return root;
        }
        if (root.right==null){
     
            return root.left;
        }
        if (root.left==null){
     
            return root.right;
        }
        TreeNode minNode=root.right;
        while (minNode.left!=null){
     
            minNode=minNode.left;
        }
        root.val=minNode.val;
        root.right=deleteMinNode(root.right);
        return root;
    }
    public TreeNode deleteMinNode(TreeNode root){
     
        if (root.left==null){
     
            TreeNode pRight=root.right;
            root.right=null;
            return pRight;
        }
        root.left=deleteMinNode(root.left);
        return root;
    }
}

LeetCode110:平衡二叉树

给定一个二叉树,判断它是否是高度平衡的二叉树。

本题中,一棵高度平衡二叉树定义为:
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

解题思路

题目中给了平衡二叉树的概念,左子树与右子树的高度差不超过1,而且是任意一颗子树都需要满足这个条件的!关于二叉树的高度,我们上面已经给出了求解方法!即递归求解中,除了验证当前节点是否满足左右子树高度差不超过1,还需要继续验证其左右子树是否也满足此条件!

代码实现

class Solution {
     
    public boolean isBalanced(TreeNode root) {
     
        if (root==null){
     
            return true;
        }
        int leftDepth=depth(root.left);
        int rightDepth=depth(root.right);
        if (Math.abs(leftDepth-rightDepth)>1){
     
            return false;
        }
        return isBalanced(root.left)&&isBalanced(root.right);
    }
    public int depth(TreeNode root){
     
        if (root==null){
     
            return 0;
        }
        int left=depth(root.left);
        int right=depth(root.right);
        return Math.max(left,right)+1;
    }
}

LeetCode222:完全二叉树的节点个数

给出一个完全二叉树,求出该树的节点个数。
说明:
完全二叉树的定义如下:在完全二叉树中,除了最底层节点可能没填满外,其余每层节点数都达到最大值,并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层,则该层包含 1~ 2h 个节点。

解题思路

首先我们要知道对于一个满二叉树,其h层一共包含有2^h个节点,那么对于本题来说完全二叉树就是最后一层,并不是每个节点的度都是2,而且节点集中在左边排列。那么我们需要做的就是先求出左右子树的高度,如果出现左右子树高度相等,那么说明左子树是颗满二叉树,叶子节点已经排到右子树了,那么对于总的节点个数就是 2^left-1再加上跟节点,再递归求解右子树!如果左右子树高度不等,即左子树大于右子树高度,那么证明右子树是颗满二叉树,总的节点个数等于2 ^right-1再加上根节点,然后递归求解左子树!

代码实现

class Solution {
     
    public int countNodes(TreeNode root) {
     
        if (root==null){
     
            return 0;
        }
        int left=countLevel(root.left);
        int right=countLevel(root.right);
        if (left==right){
     
            return (1<<left)+countNodes(root.right);
        }else {
     
            return (1<<right)+countNodes(root.left);
        }
    }
    public int countLevel(TreeNode root){
     
        if (root==null){
     
            return 0;
        }
        int left=countLevel(root.left);
        int right=countLevel(root.right);
        return Math.max(left,right)+1;
    }
}

LeetCode814:二叉树的剪枝

给定二叉树根结点 root ,此外树的每个结点的值要么是 0,要么是 1。返回移除了所有不包含 1 的子树的原二叉树。

解题思路

依据题意,我们要删除的节点一定满足以下条件:该节点左右子树为空,且该节点的值为0,那么将该节点设置为null即可!

代码实现

class Solution {
     
    public TreeNode pruneTree(TreeNode root) {
     
        return deal(root);
    }
    public TreeNode deal(TreeNode root){
     
        if (root==null){
     
            return null;
        }
        root.left=deal(root.left);
        root.right=deal(root.right);
        if (root.left==null&&root.right==null&&root.val==0){
     
            return null;
        }
        return root;
    }
}

剑指offer40:最小的k个数

输入整数数组 arr ,找出其中最小的 k 个数。例如,输入4、5、1、6、2、7、3、8这8个数字,则最小的4个数字是1、2、3、4。

解题思路

这是剑指offer上一道非常高频的题目!解题思路可以借用堆来做,本题需要用到大顶堆!在开始时,堆中元素小于k个时,先向堆中加入元素,由于题目要求最小的k个数,所以我们用大顶堆,每次将堆顶元素与遍历元素相比较,如果遍历元素小于堆顶元素,那么将堆顶元素poll,然后将当前遍历元素加入堆中,否则继续遍历!到最后遍历结束后,堆中留存的k个数就是最小的k个!这个思路一定要掌握!

代码实现

class Solution {
     
    public int[] getLeastNumbers(int[] arr, int k) {
     
        if(k>=arr.length){
     
            return arr;
        }
        if (k==0||arr.length==0){
     
            return new int[0];
        }
        PriorityQueue<Integer> queue=new PriorityQueue<>(new Comparator<Integer>() {
     
            @Override
            public int compare(Integer o1, Integer o2) {
     
                return o2-o1;
            }
        });
        for (int num:arr){
     
            if (queue.size()<k){
     
                queue.add(num);
            }else if (queue.peek()>num){
     
                queue.poll();
                queue.add(num);
            }
        }
        int[] res=new int[k];
        int index=0;
        for (int num:queue){
     
            res[index++]=num;
        }
        return res;
    }
}

剑指offer7:重建二叉树

输入某二叉树的前序遍历和中序遍历的结果,请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

解题思路

字节一面上来手撕的第一道题!这你敢说不会? 思路就是依据前序遍历(跟左右,首个元素为根节点)的第一个元素,去中序遍历中查找相应节点(中序为左根右)找到相应节点相当于在中序遍历中找到了根节点的左右子树,然后左右子树中再重复上述思路继续寻找子树的左右子树节点!

代码实现

class Solution {
     
    public TreeNode buildTree(int[] preorder, int[] inorder) {
     
        return reconstruct(preorder,0,preorder.length-1,inorder,0,inorder.length-1);
    }
    public TreeNode reconstruct(int[] pre,int startpre,int endpre,int[] in,int startin,int endin){
     
        if (startpre>endpre||startin>endin){
     
            return null;
        }
        TreeNode root=new TreeNode(pre[startpre]);
        for (int i=startin;i<=endin;i++){
     
            if (in[i]==pre[startpre]){
     
                root.left=reconstruct(pre,startpre+1,startpre+i-startin,in,startin,i-1);
                root.right=reconstruct(pre,startpre+i-startin+1,endpre,in,i+1,endin);
                break;
            }
        }
        return root;
    }
}

剑指offer37:序列化二叉树

请实现两个函数,分别用来序列化和反序列化二叉树。

解题思路

比较容易想到的序列化思路就是前序遍历(根左右),这样反序列化时也好还原树结构。即先取出根节点然后依次取出左右子树节点!

代码实现

public class Codec {
     

    // Encodes a tree to a single string.

    public String serialize(TreeNode root) {
     
        if(root==null){
     
            return "#,";
        }
        StringBuffer res=new StringBuffer(root.val+",");
        res.append(serialize(root.left));
        res.append(serialize(root.right));
        return res.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
     
        String[] str=data.split(",");
        Queue<String> queue=new LinkedList<>();
        for (int i=0;i<str.length;i++){
     
            queue.offer(str[i]);
        }
        return pre(queue);
        
    }
    public TreeNode pre(Queue<String> queue){
     
        String val=queue.poll();
        if (val.equals("#")){
     
            return null;
        }
        TreeNode node=new TreeNode(Integer.parseInt(val));
        node.left=pre(queue);
        node.right=pre(queue);
        return node;
    }
}

剑指offer34:二叉树中和为某一值的路径

输入一棵二叉树和一个整数,打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

解题思路

递归一套下来!

代码实现

class Solution {
     
    List<List<Integer>> res=new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
     
        recur(root,sum);
        return res;
    }
    public void recur(TreeNode root,int target){
     
        if (root==null){
     
            return;
        }
        path.add(root.val);
        target-=root.val;
        if (target==0&&root.left==null&&root.right==null){
     
            res.add(new ArrayList<>(path));
        }
        recur(root.left,target);
        recur(root.right,target);
        path.remove(path.size()-1);
    }
}

总结

本题来源于Leetcode中 归属于二叉树类型题目。
同许多在算法道路上不断前行的人一样,不断练习,修炼自己!
如有博客中存在的疑问或者建议,可以在下方留言一起交流,感谢各位!

觉得本博客有用的客官,可以给个点赞+收藏哦! 嘿嘿

喜欢本系列博客的可以关注下,以后除了会继续更新面试手撕代码文章外,还会出其他系列的文章!

你可能感兴趣的:(大厂手撕代码必知必会,二叉树,算法,leetcode)