【数据结构】树题谱

最新推荐文章于 2024-07-17 12:13:29 发布
最新推荐文章于 2024-07-17 12:13:29 发布
阅读量219 收藏
点赞数
文章标签： 二叉树 数据结构 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43154149/article/details/106485694
版权

文章目录

144. 二叉树的前序遍历

算法1：递归写法

/**
 * 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> preorderTraversal(TreeNode* root) {
        vector<int> res;
        dfs(res,root);
        return res;
    }

    void dfs(vector<int> &res,TreeNode* root)
    {
        if(!root) return;
        res.push_back(root->val);
        dfs(res,root->left);
        dfs(res,root->right);
    }
};

算法2：非递归遍历

/**
 * 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> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> S;

        while(root || !S.empty()) // 模板写法
        {
            while(root){
                res.push_back(root->val);
                S.push(root);
                root = root->left;
            }

            if(!S.empty())
            {
                root = S.top();
                S.pop();
                root = root->right;
            }
        }

        return res;
        
        
    }
};

94. 二叉树的中序遍历

算法1：递归写法

/**
 * 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> inorderTraversal(TreeNode* root) {
        vector<int> res;
        dfs(res,root);
        return res;
    }

    void dfs(vector<int> &res,TreeNode* root)
    {
        if(!root) return; // 记得递归返回
        if(root->left) dfs(res,root->left);
        res.push_back(root->val);
        if(root->right) dfs(res,root->right);
    }
};

算法2：非递归遍历

/**
 * 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> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> S;

        while(root || !S.empty())
        {
            while(root){
                S.push(root);
                root = root->left;
            }

            if(!S.empty())
            {
                root = S.top();
                S.pop();
                res.push_back(root->val);
                root = root->right;
            }
            
        }

        return res;
    }
};

145. 二叉树的后序遍历

算法1：递归写法

/**
 * 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> postorderTraversal(TreeNode* root) {
        vector<int> res;
        dfs(res,root);
        return res;
    }

    void dfs(vector<int> &res,TreeNode* root) // 各种遍历只是递归顺序不同
    {
        if(!root) return; // 记得递归返回
        if(root->left) dfs(res,root->left);
        if(root->right) dfs(res,root->right);
        res.push_back(root->val);
    }
};

算法2：非递归遍历

后序遍历的顺序是：左右中， 先序遍历的顺序是：中左右；
可以修改先序遍历为：中右左，再将其转置；即得到左右中，后序遍历。

/**
 * 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> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> S;

        while(root || !S.empty()) // 模板写法
        {
            while(root){
                res.push_back(root->val);
                S.push(root);
                root = root->right;
            }

            if(!S.empty())
            {
                root = S.top();
                S.pop();
                root = root->left;
            }
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

严格按照定义,第三次访问的时候输出

/**
 * 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> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;

        stack<TreeNode*> S;
        TreeNode* cur = root, *pre = NULL;
        while(cur || !S.empty())
        {
            while(cur){
                S.push(cur);
                cur  = cur->left;
            }

            cur = S.top();
            if(cur->right == NULL || cur->right == pre){
                res.push_back(cur->val);
                S.pop();
                pre = cur;
                cur = NULL;
            }else{
                cur = cur->right;
            }
        }

        return res;
    }
};

102. 二叉树的层序遍历

算法1：BFS
计算每一层有多少个元素

/**
 * 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;
        if(!root) return res; // 判空

        queue<TreeNode*> q;
        q.push(root);
        while(q.size())
        {
            int size = q.size(); // 统计每层有多少个结点
            vector<int> cur;
            for(int i=0;i<size;i++)
            {
                auto t = q.front();
                q.pop();
                cur.push_back(t->val);
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
            }
            res.push_back(cur);
        }

        return res;
    }
};

通过塞NULL来分层

/**
 * 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;
        if(!root) return res;

        queue<TreeNode*> q;
        q.push(root);
        q.push(NULL); // 通过塞NULL 来分层
        vector<int> cur;
        while(q.size())
        {
            auto t = q.front();
            q.pop();
            if(t) 
            {
                cur.push_back(t->val);
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
            }
            else
            {
                res.push_back(cur);
                cur.clear();
                if(q.size()) q.push(NULL); // 要判断有元素才加，不然死循环
            }
        }

        return res; // 记得返回
    }
};

算法2：DFS

本题使用 DFS 同样能做。由于题目要求每一层的节点都是从左到右遍历，因此递归时也要先递归左子树、再递归右子树。

DFS 做本题的主要问题是： DFS 不是按照层次遍历的。为了让递归的过程中同一层的节点放到同一个列表中，在递归时要记录每个节点的深度 level。递归到新节点要把该节点放入 level 对应列表的末尾。

当遍历到一个新的深度 level，而最终结果 res 中还没有创建 level 对应的列表时，应该在 res 中新建一个列表用来保存该 level 的所有节点。

/**
 * 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;
        dfs(res,root,0); // (res,结点，层数);
        return res;
    }

    void dfs(vector<vector<int>> &res,TreeNode* root,int level)
    {
        if(!root) return;
        if(level >= res.size()) res.push_back(vector<int>()); // 开辟空间
        res[level].push_back(root->val);
        dfs(res,root->left,level + 1);
        dfs(res,root->right,level + 1);
    }
};

107. 二叉树的层次遍历 II

将顺序的结果逆序即可

/**
 * 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>> levelOrderBottom(TreeNode* root) {
            vector<vector<int>> res;
            if(!root) return res; // 判空

            queue<TreeNode*> q;
            q.push(root);
            while(q.size())
            {
                int size = q.size(); // 统计每层有多少个结点
                vector<int> cur;
                for(int i=0;i<size;i++)
                {
                    auto t = q.front();
                    q.pop();
                    cur.push_back(t->val);
                    if(t->left) q.push(t->left);
                    if(t->right) q.push(t->right);
                }
                res.push_back(cur);
            }

            reverse(res.begin(),res.end());

            return res;
    }
};

589. N叉树的前序遍历

算法1：递归写法

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<int> preorder(Node* root) {
        vector<int> res;
        dfs(res,root);
        return res;
    }

    void dfs(vector<int> &res,Node* root)
    {
        if(!root) return;
        res.push_back(root->val);
        for(auto c : root->children) dfs(res,c);
    }
};

算法2：迭代写法

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<int> preorder(Node* root) {
        vector<int> res;
        if(!root) return res;
        stack<Node*> S;
        S.push(root);

        while(S.size())
        {
            auto t = S.top();
            S.pop();

            res.push_back(t->val);
            auto tlist = t->children;
            for(int i=tlist.size()-1;i>=0;i--) S.push(tlist[i]);
        }
        
        return res;
    }
};

590. N叉树的后序遍历

算法1：递归遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<int> postorder(Node* root) {
        vector<int> res;
        dfs(res,root);
        return res;
    }

    void dfs(vector<int> &res,Node* root)
    {
        if(!root) return;
        for(auto c : root->children) dfs(res,c);
        res.push_back(root->val);
    }
};

算法2：前序遍历加逆序

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<int> postorder(Node* root) {
        vector<int> res;
        if(!root) return res; // 判空
        stack<Node*> S;
        S.push(root);

        while(S.size()) // 根右左，逆序就变成左右根。
        {               // 根右左，需要在栈中先压入左，弹栈才是右左
            auto t = S.top();
            S.pop();
            res.push_back(t->val);
            for(auto c : t->children) 
                if(c) // 判空
                    S.push(c);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

429. N叉树的层序遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        if(!root) return res;

        queue<Node*> q;
        q.push(root);
        while(q.size())
        {
            int n = q.size();
            vector<int> cur;
            for(int i=0;i<n;i++)
            {
                auto t = q.front();
                q.pop();
                cur.push_back(t->val);
                for(auto c : t->children) q.push(c);
            }
            res.push_back(cur);
        }
        return res;

    }
};

103. 二叉树的锯齿形层次遍历

对输出改变：层数为奇数的数组逆序即可

/**
 * 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>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(!root) return res;

        queue<TreeNode*> q;
        q.push(root);
        while(q.size())
        {
            int n = q.size();
            vector<int> cur;
            for(int i=0;i<n;i++)
            {
                auto t = q.front();
                q.pop();
                cur.push_back(t->val);
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
                
            }
            res.push_back(cur);
        }

        for(int i=0;i<res.size();i++)
            if(i % 2) reverse(res[i].begin(), res[i].end());
        
        return res;
    }
};

637. 二叉树的层平均值

层序遍历

/**
 * 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<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        if(!root) return res;

        queue<TreeNode*> q;
        q.push(root);
        while(q.size())
        {
            int n = q.size();
            double cur = 0;
            for(int i=0;i<n;i++)
            {
                auto t = q.front();
                q.pop();
                cur += t->val;
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
            }
            
            res.push_back(cur / n);
        }

        return res;
    }
};

104. 二叉树的最大深度

/**
 * 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) {
        int HL,HR,MaxH;
        if(root)
        {
            HL = maxDepth(root->left);
            HR = maxDepth(root->right);
            MaxH = max(HL,HR);
            return MaxH + 1;
        }
        else return 0;
    }
};
接深度学习联系丝信
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构树题库
闲狗的博客
08-01 5614
《数据结构树之切腹攻略》 目录 华文课后题 王道课后题 华文课后题 1、给出一棵树的逻辑结构T=(N,R),其中： N={A,B,C,D,E,F,G,H,I,J,K} R={r} r={(A,B),(B,E),(B,F),(F,G),(F,H),(A,C),(C,I),(C,J),(J,K),(A,D)} 试回答下列问题： （1）哪个是F的父结点？ （2）哪些是B的子孙？...
数据结构1800试题.pdf
05-02
- **逻辑结构**：数据结构可以从逻辑上分为线性结构（如数组、链表、栈和队列）和非线性结构（如树、图）。线性结构的数据元素呈一对一关系，而非线性结构则更为复杂，如树形结构中数据元素间存在一对多或多对多...
数据结构 树练习题
qq_59183443的博客
12-04 2644
数据结构 树练习题 1.一棵有124个结点的完全二叉树，其 叶结点个数是确定的。【答案】正确【解析】完全二叉树若设二叉树的深度为h 除第 h 层外 其它各层 1～(h-1) 的结点数都达到最大个数(即1~(h-1)层为一个满二叉树) 第 h 层所有的结点都连续集中在最左边 就是完全二叉树124 = 1 + 2 + 4 + 8 + 16 + 32 + 61有61个叶节点2.二叉树中序线索化后，不存在空指针域。【答案】错误 【解析】非空二叉树中序遍历第一个结点无前驱，最后一个结点无后继，
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
chongyang_的博客
11-07 26万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
java 数据结构常见面试题
Misszhoudandan的博客
07-05 2216
因为 Set 的底层结构是 Map ，所以三者的特点和使用场景可以参考HashMap 和 TreeMap 和 LinkedHashMap ，需要注意的是，Set 中元素是不允许重复的（Set 的值是底层时存储在 Map 的 Key 中的，key 是不能重复的）。其中 Collection 是所有集合继承的最顶层接口，其中声明的方法有对集合的操作的 增删改查等，所有具体的集合类都继承这个接口。强调：使用map接口的实现类时，切记不要修改key的属性值，否则就会找不到key 所对应的 value值。
数据结构(全)
s6664的博客
06-21 5万+
线性结构, 树形结构, 图结构, 排序, 查找, 数据结构, 算法
＜ 数据结构 ＞ 树与二叉树
bit_zyx的博客
04-11 5318
目录 1、树的概念及结构 树的概念 树的专有名词 树的表示 树在实际中的运用 2、二叉树的概念及结构 概念 现实中的二叉树 特殊的二叉树 二叉树的性质 二叉树的存储结构 1、树的概念及结构 树的概念 现实中的树： 数据结构中的树： 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集...
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构——树（习题篇）
qq_59774127的博客
12-06 3410
讲解树常考的习题
数据结构——常见简答题汇总
m0_73139998的博客
11-05 5771
本文主要介绍数据结构简答题常见题型，比如：邻接表，邻接矩阵，稀疏矩阵三元组等
数据结构面试题以及答案整理
weixin_42340902的博客
07-17 4万+
一、什么是数据结构？ 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。结构包括逻辑结构和物理结构。 数据的逻辑结构包括4种 (1)集合：数据元素之间除了有相同的数据类型再没有其他的关系 (2)线性结构：数据元素之间是一对一的关系 ——线性表、栈、队列 (3)树形结构：数据元素之间是一对多的关系 (4)图状结构：数据元素之间是多对多的关系。 物理结构包括顺序存储结构和链式存储结构。 二、解释一下顺序存储与链式存储 顺序存储结构是用一段连续的存储空间来存储数据元
数据结构试题及答案
11-04
本资源提供了一份完整的数据结构试题及答案，涵盖了数据结构的基本概念、数据存储结构、算法设计、树和图论等方面的知识点。 一、单选题 1. 栈和队列的共同特点是先进后出（C）。栈和队列都是数据结构中的一种基本...
数据结构1800题答案.pdf
10-01
数据结构1800题答案的文件显然包含了大量与数据结构相关的习题解答，旨在帮助学习者深入理解和掌握这一主题。数据结构不仅仅是关于数据的简单存储，更是关于数据元素之间关系的组织方式，这些关系可以是集合、线性...
数据结构练习题.zip
04-15
以下是一些关于数据结构的关键知识点，这些知识点通常会在练习题和测试中出现： 1. **线性结构**：包括数组、链表、栈和队列等。数组是一种静态存储结构，元素在内存中是连续存放的；链表则是动态存储结构，通过...
数据结构考试题.doc
11-28
数据结构考试题解析 数据结构是一门研究非数值计算的程序设计问题中，数据元素的逻辑结构、数据信息在计算机中的存储结构、算法等的课程。本文将对数据结构考试题进行分析和解释，帮助读者更好地理解数据结构的基本...
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1055
如有错误，欢迎指出~
数据结构第32节 无锁编程
最新发布
hummhumm的专栏
07-17 836
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 826
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1892
栈超超超详解
数据结构习题与解析
"数据结构习题集，包含各章节习题，如选择题、填空题、应用题和程序设计，适用于数据结构的学习辅助" 在数据结构的学习中，理解和掌握各种概念、操作及其时间复杂度至关重要。习题集是巩固理论知识、提升实践能力的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值