我的面试准备过程--二叉树(更新中)

最新推荐文章于 2024-08-30 19:48:46 发布
最新推荐文章于 2024-08-30 19:48:46 发布
阅读量99 收藏
点赞数
文章标签： 面试 数据结构与算法
原文链接：https://segmentfault.com/a/1190000009785167
版权

写在最前面

导师贪腐出逃美国，两年未归，可怜了我。拿了小米和美团的offer，要被延期，offer失效，工作重新找。把准备过程纪录下来，共勉。

二叉树的基础

结点定义

public class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

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

二叉树的遍历

前序遍历

  • 前序遍历，递归法

    public static void preorderTraversalRec(TreeNode root) {
    if(root == null){
        return;
    }

    System.out.print(root.val + " ");
    preorderTraversalRec(root.left);
    preorderTraversalRec(root.right);
}

  • 前序遍历，迭代法
    思路：借助一个栈

    public static void preorderTraversal(TreeNode root) {
    if(null == root){
        return;
    }

    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);

    while(!stack.empty()){
        TreeNode cur = stack.pop();

        System.out.println(cur.val);

        //后入先出，因而先压右结点，再压左结点
        if(null != cur.right){
            stack.push(cur.right);
        }

        if(null != cur.left){
            stack.push(cur.left);
        }

    }
}

中序遍历

  • 中序遍历，递归法

    public static void inorderTraversalRec(TreeNode root) {
    if(null == root){
        return;
    }

    inorderTraversalRec(root.left);
    System.out.print(root.val + " ");
    inorderTraversalRec(root.right);

}

  • 中序遍历，迭代法

    public static void inorderTraversal(TreeNode root) {
    if(null == root){
        return;
    }

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

    while(true){
        while(cur != null){
            stack.push(cur);
            cur = cur.left;
        }

        if(stack.empty()){
            break;
        }

        cur = stack.pop();
        System.out.print(cur.val + " ");
        cur = cur.right;
    }

}

后序遍历

  • 后序遍历，递归法

    public static void postorderTraversalRec(TreeNode root) {
    if(null == root){
        return;
    }

    postorderTraversalRec(root.left);
    postorderTraversalRec(root.right);
    System.out.print(root.val + " ");
}

  • 后序遍历，迭代法

    public static void postorderTraversal(TreeNode root){
    if(null == root){
        return;
    }

    Stack<TreeNode> s = new Stack<TreeNode>();
    Stack<TreeNode> output = new Stack<>();

    s.push(root);
    while(!s.empty()){
        TreeNode cur = s.pop();
        output.push(cur);

        if(cur.left != null){
            s.push(cur.left);
        }

        if(cur.right != null){
            s.push(cur.right);
        }
    }

    while(!output.empty()){
        System.out.print(output.pop().val + " ");
    }
}

  • 分层遍历

    public static void levelTraversal(TreeNode root) {
    if(null == root){
        return;
    }

    Queue<TreeNode> queue = new LinkedList<>();
    queue.push(root);

    while(!queue.empty()){
        TreeNode cur = queue.removeFirst();
        System.out.print(cur.val + " ");

        if(cur.left != null){
            queue.add(cur.left);
        }

        if(cur.right != null){
            queue.add(cur.right);
        }
    }
}

求二叉树结点的个数

  • 递归解法 时间复杂度O(n)

    public static int getNodeNumRec(TreeNode root){
    if(null != root){
        return 0;
    }

    return getNodeNumRec(root.left) + getNodeNumRec(root.right) + 1;
}

  • 迭代解法 时间复杂度O(n)
    思路：与层级遍历相同，遍历的过程中纪录结点数

    public static int getNodeNum(TreeNode root){
    if(null != root){
        return 0;
    }

    int count = 1;
    Queue<TreeNode> queue = LinkedList<>();
    queue.add(root);

    while(!queue.empty()){
        TreeNode cur = queue.remove();

        if(cur.left != null){
            queue.add(cur.left);
            count++;
        }

        if(cur.right != null){
            queue.add(cur.right);
            count++;
        }
    }

    return count;
}

求二叉树的深度（高度）

  • 递归解法 时间复杂度O(n)

    public static int getDepthRec(TreeNode root) {
    if(null != root){
        return 0;
    }

    int leftDepth = getDepthRec(root.left);
    int rightDepth = getDepthRec(root.right);
    return Math.max(leftDepth, rightDepth) + 1;
}

  • 迭代解法 时间复杂度O(n)

    public static int getDepth(TreeNode root){
    if(null != root){
        return 0;
    }

    int depth = 0;
    int curLevelNodes = 1;
    int nextLevelNodes = 0;

    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);

    while(!queue.empty()){
        TreeNode cur = queue.remove();
        curLevelNodes--;

        if(cur.left != null){
            nextLevelNodes++;
            queue.add(cur.left);
        }

        if(cur.right != null){
            nextLevelNodes++；
            queue.add(cur.right);
        }

        if(curLevelNodes == 0){
            depth++;
            curLevelNodes = nextLevelNodes;
            nextLevelNodes = 0;
        }
    }

    return depth；
}

求二叉树第K层的节点个数

  • 递归解法
    思路：求以root为根的k层节点数目 等价于 求以root左孩子为根的k-1层（因为少了root那一层）节点数目 加上 以root右孩子为根的k-1层（因为少了root那一层）节点数目

    public static int getNodeNumKthLevelRec(TreeNode root, int k) {
    if(null != root || k < 0){
        return 0;
    }

    if(k == 1){
        return 1;
    }

    int leftNodeNumKth = getNodeNumKthLevelRec(root.left, k - 1);
    int rightNodeNumKth = getNodeNumKthLevelRec(root.right, k - 1);
    return leftNodeNumKth + rightNodeNumKth;
}

  • 迭代法
    思路：与求解树深度的解法相同，需要

    public static int getNodeNumKthLevel(TreeNode root, int k){
    if(root == null || k < 0){
        return 0;
    }

    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);

    int curLevelNodes = 1;
    int nextLevelNodes = 0;

    while(!queue.empty && k > 0){
        TreeNode cur = queue.remove();
        curLevelNodes--;

        if(cur.left != null){
            queue.add(cur.left);
            nextLevelNodes++;
        }

        if(cur.right != null){
            queue.add(cur.right);
            nextLevelNodes++;
        }

        if(curLevelNodes == 0){
            curLevelNodes = nextLevelNodes;
            nextLevelNodes = 0;
            k--;
        }
    }

    return curLevelNodes;
}

求二叉树中叶子节点的个数

  • 迭代法

    public static int getNodeNumLeaf(TreeNode root) {
    if(root == null){
        return 0;
    }

    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);

    int leafNodeNum = 0;

    while(!queue.empty()){
        TreeNode cur = queue.remove();

        if(cur.left != null){
            queue.add(cur.left);
        }

        if(cur.right != null){
            queue.add(cur.right);
        }

        if(cur.left == null && cur.right = null){
            leafNodeNum++;
        }
    }
    return leafNodeNum;
}

两个二叉树之间的关系

判断两棵二叉树是否相同的树。

  • 递归法

    public static boolean isSameRec(TreeNode r1, TreeNode r2) {
    if(r1 == null && r2 == null){
        return true;
    }

    if(r1 == null || r2 == null){
        return false;
    }

    if(r1.val != r2.val){
        return false;
    }

    boolean leftRes = isSameRec(r1.left, r2.left);
    boolean rightRes = isSameRec(r1.right, r2.right);

    return leftRes && rightRes;
}

  • 迭代法
    思路：遍历一遍，比对即可

    public static boolean isSame(TreeNode r1, TreeNode r2) {
    if(r1 == null && r2 == null){
        return true;
    }

    if(r1 == null || r2 == null){
        return false;
    }

    Stack<TreeNode> s1 = new Stack<>();
    Stack<TreeNode> s2 = new Stack<>();

    s1.push(r1);
    s2.push(r2);

    while(!s1.empty() && !s2.empty()){
        TreeNode n1 = s1.pop();
        TreeNode n2 = s2.pop();

        if(n1 == null && n2 == null){
            continue;
        }else if(n1 != null && n2 != null && n1.val == n2.val){
            s1.push(n1.right);
            s1.push(n1.left);
            s2.push(n2.right);
            s2.push(n2.left);
        }else{
            return false;
        }
    }
    return true;
 }

判断二叉树是不是平衡二叉树

  • 递归解法

    思路：
(1）如果二叉树为空，返回真
(2）如果二叉树不为空，如果左子树和右子树都是AVL树并且左子树和右子树高度相差不大于1，返回真，其他返回假
    public static boolean isAVLRec(TreeNode root) {
    if(root == null){
        return true;
    }

    if(Math.abs(getDepthRec(root.left) - getDepthRec(root.right)) > 1){
        return false;
    }

    return isAVLRec(root.left) && isAVLRec(root.right);
}

树的镜像

判断两个树是否互相镜像

    public static boolean isMirrorRec(TreeNode r1, TreeNode r2){
   if(r1 == null && r2 == null){
       return true;
   }

   if(r1 == null || r2 == null){
       return false;
   }

   if(r1.val != r2.val){
       return false;
   }

   return isMirrorRec(r1.left, r2.right) && isMirrorRec(r1.right, r2.left);
    }

求树的镜像

  • 递归解法
    （1）如果二叉树为空，返回空
    （2）如果二叉树不为空，求左子树和右子树的镜像，然后交换左子树和右子树

    1. 破坏原来的树

      public static TreeNode mirrorRec(TreeNode root) {
if(root == null){
   return null;
}

TreeNode left = mirrorRec(root.left);
TreeNode right = mirrorRec(root.right);

root.left = right;
root.right = left;
return root;
}

    2.保存原来的树

    public static TreeNode mirrorCopyRec(TreeNode root) {
    if(root == null){
        return null;
    }

    TreeNode newRoot = new TreeNode(root.val);
    newRoot.left = mirrorCopyRec(root.right);
    newRoot.right = mirrorCopyRec(root.left);

    return newRoot;

}

  • 迭代解法

    1. 破坏原来的树
    public static void mirror(TreeNode root) {
    if(root == null){
        return;
    }

    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(root);

    while(!stack.empty()){
        TreeNode cur = stack.pop();

        TreeNode tmp = cur.left;
        cur.left = cur.right;
        cur.right = tmp;

        if(cur.left != null){
            stack.push(cur.left);
        }

        if(cur.right != null){
            stack.push(cur.right);
        }
    }
}
    1. 不能破坏原来的树，返回一个新的镜像树
    public static TreeNode mirrorCopy(TreeNode root){
    if(root == null){
        return null;
    }

    Stack<TreeNode> stack = new Stack<>();
    Stack<TreeNode> newStack = new Stack<>();
    stack.push(root);
    TreeNode newRoot = new TreeNode(root.val);
    newStack.push(newRoot);

    while(!stack.empty()){
        TreeNode cur = stack.pop();
        TreeNode newCur = newStack.pop();

        if(cur.left != null){
            stack.push(cur.left);
            newCur.right = new TreeNode(cur.left.val);
            newStack.push(newCur.right);
        }

        if(cur.right != null){
            stack.push(cur.right);
            newCur.left = new TreeNode(cur.right.val);
            newStack.push(newCur.left);
        }
    }
    return newRoot;
}

求二叉树中两个节点的最低公共祖先节点

  • 递归法
    思路：1. 如果其中一个结点为根结点，则返回根结点

    1. 如果一个左子树找到，一个在右子树找到，则说明root是唯一可能的最低公共祖先
    2. 其他情况是要不然在左子树要不然在右子树
    public static TreeNode getLastCommonParentRec(TreeNode root, TreeNode n1, TreeNode n2) {
    if (root == null || n1 == null || n2 == null) {
        return null;
    }

    if(root.equals(n1) || root.equals(n2)){
        return root;
    }

    TreeNode commonInLeft = getLastCommonParentRec(root.left, n1, n2);
    TreeNode commonInRight = getLastCommonParentRec(root.right, n1, n2);
    if(commonInLeft != null && commonInRight != null){
        return root;
    }

    if(commonInLeft == null){
        return commonInRight;
    }

    if(commonInRight == null){
        return commonInLeft;
    }
    return root;
}

  • 迭代法

    public static TreeNode getLastCommonParent(TreeNode root, TreeNode n1, TreeNode n2){
    if(root == null || n1 == null || n2 == null){
        return null;
    }

    List<TreeNode> list1= new ArrayList<>();
    List<TreeNode> list2 = new ArrayList<>();

    boolean res1 = getNodePath(root, n1, list1);
    boolean res2 = getNodePath(root, n2, list2);

    if(!res1 || !res2){
        return null;
    }

    Iterator<TreeNode> iter1 = list1.iterator();
    Iterator<TreeNode> iter2 = list2.iterator();
    TreeNode last = null;

    while(iter1.hasNext() && iter2.hasNext()){
        TreeNode tmp1 = iter1.next();
        TreeNode tmp2 = iter2.next();

        if(tmp1 == tmp2){
            last = tmp1;
        }else{
            break;
        }
    }
    return last;
}

private static boolean getNodePath(TreeNode root, TreeNode n, List<TreeNode> path){
    if(root == null){
        return false;
    }

    path.add(root);
    if(root == n){
        return true;
    }

    boolean found = false;
    found = getNodePath(root.left, n, path);

    if(!found){
        found = getNodePath(root.right, n, path);
    }

    if(!found){
        path.remove(root);
    }

    return found;
}

本章参考http://blog.csdn.net/fightfor...

weixin_34292287
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构之二叉树（更新中）
weixin_30237281的博客
04-15 107
typedef char elemtype; struct node { elemtype data; struct node *lchild; struct node *rchild; }; typedef struct node btnode; typedef struct node *btree; void initbt(btree &t...
数据结构-二叉树-更新完整版
weixin_57535054的博客
04-30 766
二叉树详细剖析（更新完整版）（加动图更容易理解！）
树，堆（详解）二叉树在持续更新
_zhy_cq
04-26 173
二叉树的性质： 一颗非空二叉树的第i层最多有2i-1个节点 深度为h的二叉树最大的节点数为2h - 1 对于任何一个二叉树，如果叶子结点为n0,度为2的结点为n2，则n0=n2+1 n个结点的满二叉树，深度为log(n + 1) （以上是对任何的二叉树，不一定是对完全二叉树） 特殊的二叉树： 1.满二叉树 每一层的结点都是最大值，如果数的深度为h，则结点的个数为2h - 1 2.完全二叉树 前h - 1层都是满的，最后一层从左到右是连续的 // 二叉链 struct TreeNode { int va
下次面试若再被问到二叉树，希望你能对答如流！
程序人生的博客
11-26 1850
点击上方“程序人生”，选择“置顶公众号”第一时间关注程序猿（媛）身边的故事作者倪升武本文为作者投稿，如需转载，请联系原作者。曾经有个朋友问我：二叉树可以用来干啥况？我回答...
二叉树系列汇总，持续更新！
不积跬步，无以至千里！
04-27 2548
这次终于把二叉树弄懂了！
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
【链表】 链表是一种线性数据结构，其中元素以节点的...这些操作展示了链表的灵活性和多样性，理解和熟练掌握这些操作对于解决实际问题和面试准备至关重要。在实际编程中，了解和应用这些算法能够提高解决问题的效率。
python-leetcode面试题解之第94题二叉树的中序遍历-题解.zip
04-23
本压缩包文件"python-leetcode面试题解之第94题二叉树的中序遍历-题解.zip"聚焦于Python语言在解决LeetCode第94题——“二叉树的中序遍历”上的方法和思路，对于准备求职面试的程序员，尤其是Python开发者来说，这是...
python-leetcode面试题解之第111题二叉树的最小深度-题解.zip
04-29
在IT行业中，尤其是在软件开发和算法领域，LeetCode是一个非常重要的平台，它提供了大量的编程题目，帮助开发者提高技能，特别是对于准备求职面试的人来说。本压缩包文件“python-leetcode面试题解之第111题二叉树的...
python-leetcode面试题解之第144题二叉树的前序遍历-题解.zip
05-14
对于正在准备求职面试的Python开发者，熟练掌握二叉树的前序遍历是基础技能之一，同时了解如何在LeetCode上解决和提交问题也是必备的能力。通过这样的练习，你可以提升自己的编程技巧，增强对数据结构和算法的理解，...
python-leetcode面试题解之第114题二叉树展开为链表-题解.zip
05-06
在IT领域，尤其是在软件开发和算法面试中，LeetCode是一个非常重要的资源，它提供了一系列的编程挑战题，帮助开发者和求职者提升技能并准备面试。本篇内容将深入解析Python在解决LeetCode第114题——“二叉树展开为...
二叉树专题 -- 持续更新
weixin_42096202的博客
06-09 223
二叉树题目总结归纳： 二叉树结构： #include <iostream> #include <vector> #include <queue> using namespace std; class TreeNode{ public: int val; TreeNode* left; TreeNode* right; TreeN...
秋招备战-算法系列（二叉树篇）更新中。。。
zaozhichangxiaojie99的博客
08-05 148
数据结构： 四种主要的遍历思想为： 深度优先： 前序遍历：根结点 —> 左子树 —> 右子树 中序遍历：左子树—> 根结点 —> 右子树 后序遍历：左子树 —> 右子树 —> 根结点 广度优先： 层次遍历：只需按层次遍历即可 基础题 给定一个二叉树的根结点root，请依次返回二叉树的先序，中序和后续遍历(二维数组的形式)。 递归解法 /* struct Tree...
二叉树，B树之类持续更新
介么的博客
09-15 1152
二叉树二叉树嘛… 就是每个结点最多有两个子树，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^（i-1）个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T，度为0的点数=度为2的点数+1，即n_0 = n_2+1。 一棵深度为k，且有2^k-1个节点称之为满二叉树；深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中，序号为1至n的节点对应时，
数据结构-树与二叉树篇（更新中）
SDU_st的博客
11-17 401
1、树 1、树是n ( n > = 0 ) n(n>=0)n(n>=0)结点的有限集，有且仅有一个特定的称为根的结点，当n>1时，其余结点可分为m个互不相交的有限集，每个集合都是一棵树，是根的子树。 2、结点的度：子树的个数； 树的度：树的节点中最大度 叶节点（终端结点）：度为0的节点；而分支结点是度不为0的结点。 树的深度：树所有结点中最大层次（根节点的层次为1） 路径长度：结点个数-1，或者说是分支条数 兄弟结点是与当前结点父结点相同的结点 森林是m ( m > =
面试常考算法（二）——二叉树的遍历【8种】
NLP翟
05-20 357
二叉树的构造 class Node(object): """节点类""" def __init__(self, value=None, left=None, right=None): self.value = value self.left = left self.right = right class Tree(object)...
Java面试--二叉树的遍历
姜皓的博客
09-26 3300
二叉树的遍历 一、前序遍历 遍历顺序：先前序遍历树根，再前序遍历左子树，再前序遍历右子树 先遍历树根(A)--再遍历左子树(B)--再遍历左子树(D)--(D没有左子树了)再遍历右子树(E)--再遍历左子树(G)--(A没有左子树了)再遍历右子树(C)--(C没有左子树了)再遍历右子树(F) ;故顺序为 A-B-D-E-G-C-F;   二、中序遍历 遍历顺序：先中序遍历左子树...
面试基本内容
weixin_64742764的博客
08-28 1163
加载（将字节码文件加载到运行时数据区的方法区中）——>链接（验证:检查字节码文件是否合法—>准备:静态类变量赋值为默认值，不会实例变量分配初始化—>解析:将常量池引用，转化为直接引用）——>初始化。
Netty Reactor面试连环问
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
08-27 818
笔者分别带入索引0、5、8，进行与运算时，真正参与的二进制永远是和永远是7以内的进制，得出的结果分别是0、5、0，永远不会越界，并且运算性能还能得到保证。中查看是否有继续的任务，如果有则查看它的到期时间，并基于这个时长查询是否存在就绪的任务。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。
力扣234题详解：回文链表的多种解法与模拟面试问答
最新发布
10年数据\经营分析经验，现任大厂数据分析负责人
08-30 1057
本文详细解读了力扣第234题“回文链表”，通过使用双指针加反转链表和利用栈的方式高效地判断链表是否为回文，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
程序员面试算法准备：从二叉树到LeetCode刷题
在面试准备中，首先，你需要精通至少一种编程语言，例如C、C++或Java，并通过实践不断加深理解和应用。对于C语言，推荐的书籍有《C程序设计语言》和《C和指针》；对于C++，推荐《C++Primer》、《深度探索C++对象模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值