【剑指offer之树】树类型所有题总结

最新推荐文章于 2021-04-01 15:45:58 发布
最新推荐文章于 2021-04-01 15:45:58 发布
阅读量308 收藏 3
点赞数
分类专栏： 剑指offer 文章标签： 二叉树 数据结构 算法 剑指offer leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miiiiiiiiiii/article/details/109732574
版权
本文总结了剑指Offer中涉及树类型的题目，包括重建二叉树、子结构判断、二叉树镜像、对称性检查、层序遍历、特定路径求和、树的深度计算、搜索树的k大节点、平衡二叉树检测以及最近公共祖先等。通过递归和二叉树特性解决这些问题，时间复杂度大多为O(N)。
摘要由CSDN通过智能技术生成

文章目录

概述

本篇文章记录剑指offer标签为树的题，按照从简单到难。

下面的题都是在力扣上面做的，可以按照题名搜索即可

剑指 Offer 07 重建二叉树

image-20201116103426119

本题和LeetCode105题是一模一样的

前序中序建树

前序遍历：根左右

中序遍历：左根右

所以根据前序遍历第一个结点，我们能够确定该点是树的根结点，然后再根据中序遍历根节点的位置发现，中序遍历中根节点的左边的是左子树所有结点，右边的则是右子树的所有结点。再去递归的找左子树的根节点和右子树的根节点。

image-20201116103528608

时间复杂度O(N)，空间复杂度O(N)

因为用哈希表优化了在中序遍历中找前序遍历确定的根节点的位置，所以时间复杂优化到了O(N)

AC 代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    unordered_map<int,int> h;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        //特判空树
        if (preorder.empty()) return NULL;
        //将中序遍历插入哈希表
        for (int i = 0 ; i < inorder.size(); i ++) h[inorder[i]] = i;
        //建树
        return build(preorder, inorder ,0 , preorder.size() - 1 , 0 , preorder.size() - 1  );
    }

    TreeNode* build(vector<int>& pre, vector<int>& inorder, int pl ,int pr , int inl , int inr){
        //递归终止条件
        if (pl > pr) return NULL;
        //确定根节点
        auto root = new TreeNode(pre[pl]);
        int k = h[root->val];
        //建左子树
        root->left = build(pre, inorder, pl + 1, pl + 1 + k - inl -1 ,inl,k - 1);
        //建右子树
        root->right = build(pre, inorder, pl + 1 + k - inl -1 + 1,pr, k + 1,inr);
        return root;
    }
};

剑指 Offer 26 树的子结构

image-20201116105031104

枚举

该题有点类似与字符串匹配问题。

由于第二棵树可能是从第一棵树某个结点开始的子树，所以我们对于第一棵树的每个结点，来枚举第二棵树，向下判断是否匹配，一直到第一棵树枚举完，说明第二棵树不是第一棵树的子树。

时间复杂度O(NM)，N和M分别是第一棵树和第二棵树的结点个数

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        //枚举完，不匹配
        if (!A || !B) return false;
        //匹配成功
        if (isPart(A,B)) return true;
        //枚举一树的左子树和右子树
        return isSubStructure(A->left,B) || isSubStructure(A->right , B);
    }

    //匹配一树部分和二树
    bool isPart(TreeNode* p1, TreeNode* p2){
        //匹配成功
        if(!p2) return true;
        //一树空或者值不同
        if (!p1) return false;
        if (p1->val != p2->val) return false;
        //递归匹配左子树和右子树
        return isPart(p1->left, p2->left) && isPart(p1->right, p2->right);
    }
};

剑指 Offer 27 二叉树的镜像

image-20201116121508344

和LeetCode的226一模一样

翻转二叉树

大致意思是左右两个子树交换一下位置，用递归来实现。

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        //递归终止条件
        if (!root) return NULL;
        //交换左右子树
        swap(root->left, root->right);
        //递归交换左边和右边
        mirrorTree(root->left);
        mirrorTree(root->right);
        return root;
    }
};

剑指 Offer 28 对称的二叉树

image-20201116122757765

递归判断

判断左子树和右子树是否对称

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        //空树
        if (!root) return true;
        //判断左子树和右子树
        return dfs(root->left, root->right);
    }

    bool dfs(TreeNode* p1, TreeNode* p2){
        //同时空
        if (!p1 && !p2) return true;
        //不同时空
        if (!p1 || !p2) return false;
        //值不相等
        if (p1->val != p2->val) return false;
        //1树左子树和2树右子树，1树右子树和2树左子树
        return dfs(p1->left, p2->right) && dfs(p1->right, p2->left) ;
    }
};

剑指 Offer 32 - I 从上到下打印二叉树

image-20201116131035891

二叉树的层序遍历

利用队列，层序遍历

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> levelOrder(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> q;
        //空树不入队
        if (root) q.push(root);
        //层序遍历过程
        while (q.size()){
            auto t = q.front();
            q.pop();
            res.push_back(t->val);
            if (t->left) q.push(t->left);
            if (t->right) q.push(t->right);
        }
        return res;

    }
};

剑指 Offer 32 - II 从上到下打印二叉树 ||

image-20201116131537491

二叉树的层序遍历(分层)

分层的二叉树层序遍历，每次只需要直接从队列计算当前层的大小即可。

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> q;
        if (root) q.push(root);
        //层序遍历
        while (q.size()){
            //计算当前层个数
            auto len = q.size();
            vector<int> level;
            //记录当前层所有结点
            for (int i = 0 ; i < len; i ++){
                auto t = q.front();
                q.pop();
                level.push_back(t->val);
                if (t->left) q.push(t->left);
                if (t->right) q.push(t->right);
            }
            res.push_back(level);
        }
        return res;
    }
};

剑指 Offer 32 - III 从上到下打印二叉树 |||

image-20201116132110247

二叉树的层序遍历

题目是二叉树层序遍历的变形，大致的意思是S型的打印，我们可以发现规律，如果根节点为第0层的话，那么奇数层是从后到前遍历，偶数层是从前到后遍历。即奇数层记录的需要翻转。

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> q;
        if (root) q.push(root);
        //层序遍历
        while (q.size()){
            int len = q.size();
            vector<int> level;
            for (int i = 0 ; i < len ; i ++){
                auto t = q.front();
                q.pop();
                level.push_back(t->val);
                if (t->left) q.push(t->left);
                if (t->right) q.push(t->right);
            }
            //奇数层
            if (res.size() & 1) reverse(level.begin(), level.end());
            res.push_back(level);
        }
        return res;
    }
};

剑指 Offer 34 二叉树中和为某一值的路径

image-20201116133016406

递归枚举

从上往下找，如果存在一条根节点到叶节点的路径为sum，则是答案。我们可以递归的去找。

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        if (!root) return res;
        dfs(root, sum);
        return res;
    }

    void dfs(TreeNode* p, int sum){
        path.push_back(p->val);
        sum -= p->val;
        //叶节点
        if (sum == 0 && !p->left && !p->right) res.push_back(path);
        //左子树和右子树
        if (p->left) dfs(p->left, sum);
        if (p->right) dfs(p->right, sum);
        //恢复现场
        path.pop_back();
    }
};

剑指 Offer 55 - I 二叉树的深度

image-20201116135445842

递归求二叉树的深度

递归求二叉树深度

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        //空树
        if (!root) return 0;
        //递归左子树右子树
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

剑指 Offer 54 二叉搜索树的第k大节点

image-20201116135730128

二叉树搜索树中序遍历有序

利用二叉搜索树中序遍历有序的性质，当我们中序遍历到第k个节点，即该节点即答案。

该题是第k大的数，并不是第k小的数，所以中序遍历我们需要先右子树，再左子树。

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int res;
    int kthLargest(TreeNode* root, int k) {
        dfs(root,k);
        return res;
    }

    void dfs(TreeNode* root, int& k ){
        if (!root) return ;
        //先递归右子树
        dfs(root->right,k);
        k --;
        if (k == 0) res = root->val;
        //递归左子树
        else dfs(root->left, k); 
    }
};

剑指 Offer 55 - II 平衡二叉树

image-20201116143627360

平衡二叉树

利用平衡二叉树的定义判断

如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。我们递归的求左右子树的高度，判断左右子树高度差即可。dfs

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool res = true;
    bool isBalanced(TreeNode* root) {
        //遍历
        dfs(root);
        return res;
    }

    int dfs(TreeNode* root){
        //空树
        if (!root) return 0;
        //左右子树高度
        int lh = dfs(root->left);
        int rh = dfs(root->right);
        //判断高度差
        if (abs(lh - rh) > 1) res = false;
        //返回高度
        return max(lh, rh) + 1;

    }

};

剑指 Offer 68 - II 二叉树的最近公共祖先

image-20201116215331618

公共祖先

对于任意一个点，他自己，他的父亲，父亲的父亲…都是该点的祖先。

对于两个点来说，两个点的父亲肯定有相交的祖先，找到离两个点最近的公共的祖先，就是二叉树的最近公共祖先，也称为最低公共祖先

image-20201116215739073

例如对于7和6来说，5是他们最近的公共祖先

对于该问题有两种情况

1.对于某个点来说，两个点分别在该节点的左子树和右子树，则该点就是两点的最近公共祖先image-20201116215933165

2.对于某个点来说，该点就是两点之一，另外一个点在该点的左子树或者右子树，所以该点就是两点的最近公共祖先

image-20201116220238247

思路:

我们根据定义来搜索即可。

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        //递归终止条件
        if (!root) return NULL;
        if (root == q || root == p) return root;
        //递归找左边和右边找q、p
        auto left = lowestCommonAncestor(root->left, p, q);
        auto right = lowestCommonAncestor(root->right, p, q);
        //一个左边一个右边
        if (left && right) return root;
        //都在左边
        if (left) return left;
        //右边
        return right;
    }
};

剑指 Offer 37 序列化二叉树

image-20201116231309542

序列化

为了后面方便建树，采用的是前序遍历来序列化和建树。

为什么只有前序遍历能够确定树呢？

这是因为我们序列化的时候空节点也记录了，所以能够确定树。

前序遍历来序列化，遇到空节点用#表示。当建树的时候也是一样，根据前序遍历来建树。

时间复杂度O(N)

AC代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string res;
        dfs_s(root, res);
        return res;
    }
    
    //先序遍历序列化
    void dfs_s(TreeNode* root , string& res){
        //空节点用#表示
        if (!root){
            res += "#,";
            return;
        }
        res += to_string(root->val) + ',';
        //左右子树
        dfs_s(root->left, res);
        dfs_s(root->right, res);
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        int u = 0 ;
        return dfs_d(data, u);
    }

    TreeNode* dfs_d(string& res, int& u ){
        //空节点
        if (res[u] == '#'){
            u += 2;
            return NULL;
        }
        //计算根节点
        int k = u;
        while (res[u] != ',') u++;
        auto root = new TreeNode(stoi(res.substr(k, u - k)));
        u ++;
        //递归左子树和右子树
        root->left = dfs_d(res, u);
        root->right = dfs_d(res, u);
        return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec ser, deser;
// TreeNode* ans = deser.deserialize(ser.serialize(root));
Miiiiiiiiiii
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指Offer（第二版）面试案例：树中两个节点的最低公共祖先节点
冷血之心的博客
07-06 5572
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/74612786冷血之心的博客） 剑指Offer（第二版）面试案例：树中两个节点的最低公共祖先节点 题目：输入两个树节点，求它们的最低公共祖先节点。 反问：这棵树是不是二叉树？ 面试官：是二叉树，并且是二叉搜索树。 思路： 二叉搜索树是经过排序的，位于左子树...
【LeetCode之树总结】 树类型所有题总结
Miiiiiiiiiii的博客
11-18 315
文章目录树94. 二叉树的中序遍历二叉树的遍历递归写法非递归写法95. 不同的二叉搜索树 ||利用二叉搜索树中序遍历有序性96.不同的二叉搜索树二叉搜索树中序遍历有序性98. 验证二叉搜索树二叉搜索树中序遍历有序性中序遍历中验证是否满足二叉搜索树的性质100. 相同的树递归101. 对称二叉树解题102. 二叉树的层序遍历层序遍历103. 二叉树的锯齿形层次遍历二叉树的层序遍历104. 二叉树的最大深度dfs一行代码层序遍历求深度105. 从前序与中序遍历序列构造二叉树(经典)前序中序建树106. 从中序与
剑指offer——树
weixin_44728238的博客
03-03 142
树的题主要就是依赖于递归来实现，一定要学好递归！！！ （一）剑指Offer 07.重建二叉树 基本思路： 1.这道题就是简单地根据前序遍历和后续遍历来创建二叉树，方法如下：前序遍历的第一个元素是根节点，根据根节点在中序遍历中的位置，左侧为左子树，右侧为右子树，然后再递归构建左右子树即可。 class Solution { public TreeNode buildTree(int[] preorder, int[] inorder) { //把前序遍历的值和中序遍历的值放到list中
剑指offer（树的算法题）
u012864854的博客
05-21 478
本文包含以下算法题：1.重建二叉树（面试题6）2.树的子结构（面试题18）3.二叉树的镜像（面试题19）4.从上往下打印二叉树（面试题23）5.二叉搜索树的后序遍历序列（面试题24）6.二叉树中和为某一值的路径（面试题25）7.二叉搜索树与双向链表（面试题27）8.二叉树的深度（面试题39）9.平衡二叉树（与上题相关）10.二叉树的下一个结点（面试题58）11.对称的二叉树（面试题59）12.把二...
判断B是否A的子结构
qq_30629571的博客
06-05 313
题目描述 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） public class Solution { public static boolean HasSubtree(TreeNode root1, TreeNode root2) { boolean result = false; //当Tree1和Tre
二叉树遍历及树类型的判断
qq_18668139的博客
07-28 332
二叉树及树类型的判断 内容：树定义,前、中、后 、层次遍历，树的高度，判断树是否平衡、是否是二叉搜索树、是否是AVL树 一. 定义 typedef struct TNode *PtrToTNode; typedef PtrToTNode BinTree; struct TNode{ TElemType data; BinTree left; BinTree right; }; 二. 树的基本操作 2.1 树的创建 BinTree CreateBinTree(){ BinTree T; in
《剑指Offer》刷题笔记——面试题36. 二叉搜索树与双向链表
12-22
《剑指Offer》中的面试题36探讨了一个有趣的问题，即如何将一棵二叉搜索树转化为一个双向链表。这道题目主要考察了对二叉搜索树（BST）特性的理解以及链表操作的能力。 首先，我们要明确二叉搜索树的基本特性：对于...
Python《剑指offer》算法实现-树的宽度
最新发布
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
剑指offer刷题记录——树
01-20
BFS即可，树的题目切记刚开始要判断顶点是否为空。 具体实现 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ ...
《剑指Offer》学习80题java版本.zip
03-10
《剑指Offer》是一本备受推崇的编程面试指南，它为应聘者提供了深入理解数据结构和算法的机会，以提升在面试中的竞争力。本书涵盖了80个精心设计的问题，旨在帮助求职者熟练掌握Java语言中的核心概念和技术。在这里...
Leetcode刷题：剑指offer【面试题07】
01-20
文章目录思路 1：递归 【面试题07】重建二叉树 难度： 中等 限制： 0 <= 节点个数 <= 5000 输入某二叉树的前序遍历和中序遍历的结果，请...树的遍历方式： 深度优先遍历，前/中/后序遍历属于深度遍历的一种实现
剑指offer-数据结构二——树
GorMing 的博客
02-08 157
剑指offer-数据结构二——树剑指offer-数据结构—树1.重建二叉树2.二叉树的下一个节点3.树的子结构4.二叉树的镜像5.对称的二叉树6.层次遍历二叉树7.二叉树的后序遍历序列 剑指offer-数据结构—树 1.重建二叉树 题目描述： 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5...
剑指offer---关于树的题目解答---第二弹
szy2333的博客
11-13 137
平衡二叉树 解题思路： 平衡二叉树是什么？基于二叉树，但是左右子树的高度差不能超过1 那么使用递归实现，首先每次求出左右子树的高度，如果左右子树的高度差小于等于1，继续进行递归，否则不是一个平衡树 代码实现： public class IsBalanced_Solution { public boolean IsBalanced_Solution(TreeNode root...
重建二叉树——【一天一道算法题】
深海微澜
11-21 174
解法就是递归的思想 分析： 根据中序遍历和前序遍历可以确定二叉树，具体过程为： 根据前序序列第一个结点确定根结点 根据根结点在中序序列中的位置分割出左右两个子序列 对左子树和右子树分别递归使用同样的方法继续分解 例如： 前序序列{1,2,4,7,3,5,6,8} = pre 中序序列{4,7,2,1,5,3,8,6} = in 根据当前前序序列的第一个结点确定根结点，为 1 找到 1...
《剑指offer》刷题（2）树
weixin_44369928的博客
07-28 127
今天写写《剑指offer》中树的解题思路 文章目录07.重建二叉树26.树的子结构27.二叉树的镜像32.Z型从上到下打印二叉树34.二叉树中和为某一值的路径（重点）37. 序列化二叉树54. 二叉搜索树的第k大节点（经典）55 - II. 平衡二叉树（经典）68 - I. 二叉搜索树的最近公共祖先68 - II. 二叉树的最近公共祖先（重点） 07.重建二叉树 题目：输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 思路：前序遍历[根左右]，中
剑指offer-树专题
zuyuhuo6777的博客
07-17 165
1、二叉树的深度 使用递归（栈 DFS） 一颗树的深度可以看做其左右子树深度的较大值再加1 思路： 1. 树只有一个节点，则深度为1 2. 根节点只有左子树没有右子树，树的深度为左子树深度加1 3.根节点只有右子树没有左子树，树的深度为右子树深度加1 4.根节点既有右子树又有左子树，树的深度为左、右子树深度的较大值加1 # class TreeNode: # def _...
剑指offer——树篇
weixin_42072280的博客
03-31 245
面试题32-I.从上到下打印二叉树 //java anan 2020.3.31 class Solution { public int[] levelOrder(TreeNode root) { if(root == null) return new int[0]; //输入：[] Queue<TreeNode> queue = new...
剑指offer ：树类题目汇总
danjuanzi2684的博客
11-15 279
7.重建二叉树：          输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。        解题思路：把重建二叉树分解为构建左右子树。根据题目给出的前序遍历、中序遍历数组，首先找出根节点 ， 然后再根...
剑指offer专题——树（题量：15）
m0_46195138的博客
04-01 117
文章目录剑指offer 04————重建二叉树 剑指offer 04————重建二叉树 题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 示例： 输入 [1,2,3,4,5,6,7],[3,2,4,1,6,5,7] 返回值 {1,2,5,3,4,6,7} 解题思路 1 前序遍历由3部分组成，1.头节点
剑指Offer：Java解法的65道题全集
"剑指Offer-V1.pdf 是一个包含65道题目的算法和数据结构练习集，专注于Java语言的解决方案。这份资源旨在帮助提升编程面试技能，覆盖了各种难度的题目，包括但不限于数组、链表、栈、队列、树、图、回溯、动态规划等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值