leetcode--二叉树和图

最新推荐文章于 2023-08-10 14:45:58 发布
最新推荐文章于 2023-08-10 14:45:58 发布
阅读量567 收藏 1
点赞数
分类专栏： leetcode 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiayto/article/details/78766006
版权

基础知识

二叉树的数据结构

struct TreeNode{
    int val;   //数据域
    TreeNode *left //左右指针
    TreeNode *right
    TreeNode(int x):val(x),left(NULL),right(NULL){}
    //构造函数
}

构造二叉树

构造如下的一棵二叉树：
二叉树

int main(){
    TreeNode a(1);
    TreeNode b(2);
    TreeNode c(3);
    TreeNode d(4);
    TreeNode e(5);
    TreeNode f(6);
    a.left=&b;
    a.right=&c;
    b.left=&d;
    b.right=&e;
    c.right=&f;
}

二叉树的深度遍历

前序遍历访问
traversal(node->left)
中序遍历访问
traversal(node->right)
后序遍历访问

前中后指的是访问根节点的顺序，前序：先根再左再右

二叉树的层次遍历

也就是广度优先搜索，用队列一层一层的访问节点，访问一个节点压入该节点的孩子节点，队列不空，持续该过程。
这里写图片描述

void BFS_print(TreeNode* root){
    queue<TreeNode*> Q;
    Q.push(root);
    while(!Q.empty()){
        TreeNode* node=Q.front();
        Q.pop();
        printf("(%d)\n",node->val);
        if(node->left){
            Q.push(node->left;
        }
        if(node->right){
            Q.push(node->right;
        }
    }
}

leetcode题目

113 Path Sum

题意：

给定一个二叉树与整数sum，找出所有从根节点到叶节点的路径，要求这些路径上节点值的和等于sum。

解题思路：

用深度优先搜索路径。
1 先序遍历时将节点值存储到path栈中，path_value累加节点值
2 当遍历到叶节点时判断path_value是不是等于sum，if等于push进result中。
3 在后序遍历时，将节点从path栈中弹出，path_value减去节点值

代码：

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> result;
        vector<int> path;
        int path_value=0;
        preorder(root,path_value,sum,path,result);
        return result;
    }
private:
    void preorder(TreeNode *node,int &path_value,int sum,vector<int> &path,vector<vector<int>> &result){
        //先序遍历内容：
        if(!node){
            return;
        }
        path_value=path_value+node->val;
        path.push_back(node->val);
        if(!node->left&&!node->right&&path_value==sum){
            result.push_back(path);
        }
        preorder(node->left,path_value,sum,path,result);
        preorder(node->right,path_value,sum,path,result);
        //后序遍历内容:
        path.pop_back();
        path_value=path_value-node->val;
    }
};

236 Lowest Common Ancestor of a Binary Tree

题意：

给出两个节点，求出他们最近的公共祖先。

解题思路：

1 用深度优先搜索找点，找到点后保存路径。
2 同时遍历两个路径，找最后一个相同点。

代码：

void preorder(TreeNode* node,
              TreeNode *search,
              std::vector<TreeNode*> &path,
              std::vector<TreeNode*> &result,
              int &finish){
    if (!node || finish){
        return;      //结束技巧，finish用于标记已找到节点
    }
    path.push_back(node);
    if (node == search){
        finish = 1;
        result = path;
    }
    preorder(node->left, search, path, result, finish);
    preorder(node->right, search, path, result, finish);
    path.pop_back();//后序遍历时根节点要做退出操作，就是左右节点都不是要找的点，根节点弹出
}

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        std::vector<TreeNode*> path;
        std::vector<TreeNode*> node_p_path;
        std::vector<TreeNode*> node_q_path;
        int finish = 0;
        preorder(root, p, path, node_p_path, finish);//找p点的路径并保存于node_p_path
        path.clear();
        finish = 0;
        preorder(root, q, path, node_q_path, finish);//找q点的路径并保存于node_q_path
        int path_len = 0;
        if (node_p_path.size() < node_q_path.size()){
            path_len = node_p_path.size();
        }
        else{
            path_len = node_q_path.size();
        }
        TreeNode *result = 0;
        //找两个路径中最后一个相同点
        for (int i = 0; i < path_len; i++){
            if (node_p_path[i] == node_q_path[i]){
                result = node_p_path[i];//少写一点代码
            }
        }
        return result;
    }
};

114. Flatten Binary Tree to Linked List

题意：

不用大的额外空间，将二叉树转换为链表，left为null，right为链表的next指针。链表的顺序是树的先序遍历。

解题思路：

如果不考虑大的额外空间，最简单的做法是用一个vector存先序遍历的结果，然后遍历这个vector。

代码：

class Solution {
public:
    void flatten(TreeNode *root) {
        std::vector<TreeNode *> node_vec;
        preorder(root, node_vec);
        for (int i = 1; i < node_vec.size(); i++){
            node_vec[i-1]->left = NULL;
            node_vec[i-1]->right = node_vec[i];
        }
    }
private:
    void preorder(TreeNode *node,vector<TreeNode *> &node_vec){
        if (!node){
            return;
        }
        node_vec.push_back(node);
        preorder(node->left, node_vec);
        preorder(node->right, node_vec);
    }
};

解题思路2：

思考过程是：独立开树的一部分，思考前中后遍历时候应该做什么。考虑输入和输出:
* 先序遍历：第一次访问根节点时，我们要保留左右节点，让right指针指向左节点。右指针指向NULL。
* 中序遍历：第二次访问根节点，这时左子树完成了链表变形，要将左子树的最后节点指向，右子树的开始节点。所以要输出一个末尾节点，可以用&引用去维护。
* 后续遍历：维护最末的节点。

代码：

class Solution {
public:
    void flatten(TreeNode* root) {
        TreeNode *last=NULL;
        preorder(root,last);
    }
private:
    void preorder(TreeNode* node,TreeNode* &last){
        //*& TreeNode*的意思是传入TreeNode的指针变量，&是可以在函数中改变这个变量
        if(!node){
            return;
        }
        if(!node->left&&!node->right){
            last=node;
            return;
        }
        TreeNode* left=node->left; //保留左右节点
        TreeNode* right=node->right;
        TreeNode* left_last=NULL;//初始化要维护的末尾节点。
        TreeNode* right_last=NULL;
        if(left){
            preorder(left,left_last);//递归，维护左子树的末尾节点
            node->left=NULL; //放在中序遍历执行时因为可以省去判断是否有左子树的语句。
            node->right=left;
            last=left_last;
        }
        if(right){
            preorder(right,right_last);
            if(left_last){
                left_last->right=right;//让左子树的末尾节点指向右子树的开始节点。放在后序遍历执行可以省去判断是否有右子树的语句。
            }
            last=right_last;//维护右子树的末尾节点
        }
    }
};

199.Binary Tree Right Side View

题意：

从右边观察二叉树，输出每一层最右边的节点。

解题思路：

层次遍历二叉树，将节点和层数绑定微pair，压入队列时，将节点和层数同时压入，记录每一层的最后一个节点。

代码：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> view; //存储每层最后的节点。
        queue<pair<TreeNode*,int>> Q;
        //广度优先搜索，用一个pair存储节点和它对应的层数。
        if(root){
            Q.push(make_pair(root,0));
        }
        while(!Q.empty()){
            TreeNode* node=Q.front().first;  
            int depth=Q.front().second;
            Q.pop();
            if(view.size()==depth){
                view.push_back(node->val); //当出现新的层时压入一个节点。
            }
            else{
                view[depth]=node->val;
            }
            if(node->left){
                Q.push(make_pair(node->left,depth+1));  //压入左节点，标记为下一层
            }
            if(node->right){
                Q.push(make_pair(node->right,depth+1)); //压入右节点，标记为下一层
            }
        }
        return view;
    }
};

图

图

图的表示（邻接矩阵）：

这里写图片描述

代码：
int main(){
    const int MAX_N = 5;
    int Graph[MAX_N][MAX_N] = {0};
    Graph[0][2] = 1;
    Graph[0][4] = 1;
    Graph[1][0] = 1;
    Graph[1][2] = 1;
    Graph[2][3] = 1;
    Graph[3][4] = 1;
    Graph[4][3] = 1;
    printf("Graph:\n");
    for (int i = 0; i < MAX_N; i++){
        for (int j = 0; j < MAX_N; j++){
            printf("%d ", Graph[i][j]);
        }
        printf("\n");
    }
    return 0;
}

表示稠密图作用比较大，但是表示稀疏图一般用邻接表。

图的表示（邻接表）：

这里写图片描述

代码：
#include <stdio.h>
#include <vector>

struct GraphNode{
    int label;
    std::vector<GraphNode *> neighbors;
    GraphNode(int x) : label(x) {};
};

int main(){ 
    const int MAX_N = 5;
    GraphNode *Graph[MAX_N];

    for (int i = 0; i < MAX_N; i++){
        Graph[i] = new GraphNode(i);
    }

    Graph[0]->neighbors.push_back(Graph[2]);
    Graph[0]->neighbors.push_back(Graph[4]);
    Graph[1]->neighbors.push_back(Graph[0]);
    Graph[1]->neighbors.push_back(Graph[2]);
    Graph[2]->neighbors.push_back(Graph[3]);
    Graph[3]->neighbors.push_back(Graph[4]);
    Graph[4]->neighbors.push_back(Graph[3]);

    printf("Graph:\n");
    for (int i = 0; i < MAX_N; i++){
        printf("Label(%d) : ", i);
        for (int j = 0; j < Graph[i]->neighbors.size(); j++){
            printf("%d ", Graph[i]->neighbors[j]->label);
        }
        printf("\n");
    }
    for (int i = 0; i < MAX_N; i++){
        delete Graph[i];
    }
    return 0;
}

深度优先搜索

struct GraphNode{
    int label;
    std::vector<GraphNode *> neighbors;
    GraphNode(int x) : label(x) {};
};

void DFS_graph(GraphNode *node, int visit[]){
    visit[node->label] = 1;
    printf("%d ", node->label);
    for (int i = 0; i < node->neighbors.size(); i++){
        if (visit[node->neighbors[i]->label] == 0){
            DFS_graph(node->neighbors[i], visit);
        }
    }
}

广度优先搜索

struct GraphNode{
    int label;
    std::vector<GraphNode *> neighbors;
    GraphNode(int x) : label(x) {};
};

void BFS_graph(GraphNode *node, int visit[]){
    std::queue<GraphNode *> Q;
    Q.push(node);
    visit[node->label] = 1;
    while(!Q.empty()){
        GraphNode *node = Q.front();
        Q.pop();
        printf("%d ", node->label);
        for (int i = 0; i < node->neighbors.size(); i++){
            if (visit[node->neighbors[i]->label] == 0){
                Q.push(node->neighbors[i]);
                visit[node->neighbors[i]->label] = 1;
            }
        }
    }
}

leetcode题目

207. Course Schedule

题意：给出课程之间的依赖关系，求是否可以将所有的课程全部完成。其实就是求有向图是否有环。

解题思路一：

  • 用深度优先搜索，如果递归搜索某一条路径时发现路径中有重复的节点，则有环，不能完成。
  • 这里的visit的数组要设计三种状态：-1是未被搜索，0是正在被搜索的路径上，1是已经完成搜索的节点。
  • 像递归二叉树思考方式一样，思考先序中序后序遍历要进行什么操作：
    • 先序遍历：将该节点标记状态visit为0
    • 中序遍历：如果访问过程中出现访问到visit为0的点则返回false
    • 后续遍历：访问完成将该节点标记状态visit为-1

代码：

struct GraphNode{
    int label;
    std::vector<GraphNode *> neighbors;
    GraphNode(int x) : label(x) {};
};
bool DFS_graph(GraphNode *node, std::vector<int> &visit){
    visit[node->label] = 0;
    for (int i = 0; i < node->neighbors.size(); i++){
        if (visit[node->neighbors[i]->label] == -1){
            if (DFS_graph(node->neighbors[i], visit) == 0){
                return false;
            }
        }
        else if (visit[node->neighbors[i]->label] == 0){
            return false;
        }
    }
    visit[node->label] = 1;
    return true;
}

class Solution {
public:
    bool canFinish(int numCourses,
        std::vector<std::pair<int, int> >& prerequisites) {
        std::vector<GraphNode*> graph;
        std::vector<int> visit;
        for (int i = 0; i < numCourses; i++){
            graph.push_back(new GraphNode(i));
            visit.push_back(-1);
        }
        for (int i = 0; i < prerequisites.size(); i++){
            GraphNode *begin = graph[prerequisites[i].second];
            GraphNode *end = graph[prerequisites[i].first];
            begin->neighbors.push_back(end);
        }
        for (int i = 0; i < graph.size(); i++){
            if (visit[i] == -1 && !DFS_graph(graph[i], visit)){
                return false;
            }
        }
        for (int i = 0; i < numCourses; i++){
            delete graph[i];
        }
        return true;
    }
};

解题思路二：

用广度优先搜索，用入度的概念，每次只将入度为0的点压入队列，它指向的所有节点的入度都-1，-1后入度为0的点可以压入队列，如果能遍历整个图，则可以完成，不能遍历则不能完成。

代码：

struct GraphNode{
    int label;
    std::vector<GraphNode *> neighbors;
    GraphNode(int x) : label(x) {};
};

class Solution {
public:
    bool canFinish(int numCourses,
        std::vector<std::pair<int, int> >& prerequisites) {
        std::vector<GraphNode*> graph;
        std::vector<int> degree;
        for (int i = 0; i < numCourses; i++){
            degree.push_back(0);
            graph.push_back(new GraphNode(i));
        }
        for (int i = 0; i < prerequisites.size(); i++){
            GraphNode *begin = graph[prerequisites[i].second];
            GraphNode *end = graph[prerequisites[i].first];
            begin->neighbors.push_back(end);
            degree[prerequisites[i].first]++;
        }       
        std::queue<GraphNode *> Q;
        for (int i = 0; i < numCourses; i++){
            if (degree[i] == 0){
                Q.push(graph[i]);
            }
        }
        while(!Q.empty()){
            GraphNode *node = Q.front();
            Q.pop();
            for (int i = 0; i < node->neighbors.size(); i++){
                degree[node->neighbors[i]->label]--;
                if (degree[node->neighbors[i]->label] == 0){
                    Q.push(node->neighbors[i]);
                }
            }
        }       
        for (int i = 0; i < graph.size(); i++){
            delete graph[i];
        }       
        for (int i = 0; i < degree.size(); i++){
            if (degree[i]){
                return false;
            }
        }
        return true;
    }
};
xiayto
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【leetcode-树】二叉树的序列化与反序列化
12-21
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机...提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 Leet
数据结构——二叉树
qq_46582938的博客
08-02 2810
数据结构与算法
邻接表存储二叉树
qq_37857292的博客
08-05 529
邻接表存二叉树
数据结构与算法——二叉树与图
zxr916的博客
04-20 489
文章目录1.预备知识1.1 二叉树定义1.2 二叉树的构造2.路径总和 II2.1 题目描述2.2 算法思路2.3 C++实现3.二叉树的最近公共祖先3.1 题目描述3.2 解题思路3.3 C++实现4.二叉树展开为链表4.1 题目描述4.2 思考4.3 C++实现 1.预备知识 1.1 二叉树定义 1.2 二叉树的构造 2.路径总和 II 2.1 题目描述 给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。 叶子节
【数据结构】详解二叉树|图
Saki_Python的博客
08-10 636
最优二叉树又称哈夫曼树，是一类带权路径长度最短的树。路径：树中一个结点到另一个结点之间的通路。结点的路径长度：路径上的分支数树的路径长度：根结点到达每一个叶子结点之间的路径长度之和权：结点代表的值结点的带权路径长度：该结点到根结点之间的路径长度乘以该结点的权值树的带权路径长度（树的代价）：树的所有叶子结点的带权路径长度之和哈夫曼树的求法：给出一组权值，将其中最小的两个权值作为叶子结点，其和作为父结点，组成二叉树，然后删除这两个叶子结点权值，将父结点的值添加到这组权值中。
二叉树的存储方式【顺序储存（数组）、链式存储、邻接表存储等】
热门推荐
马小超
09-18 1万+
1.顺序存储结构 二叉树的顺序存储，就是用一组连续的存储单元存放二叉树中的结点。因此，必须把二叉树的所有结点安排成为一个恰当的序列，结点在这个序列中的相互位置能反映出结点之间的逻辑关系，用编号的方法从树根起，自上层至下层，每层自左至右地给所有结点编号,缺点是有可能对存储空间造成极大的浪费，在最坏的情况下，一个深度为k且只有k个结点的右单支树需要2k-1个结点存储空间。 依据二叉树的性质，完全二叉树和满二叉树采用顺序存储比较合适，树中结点的序号可以唯一地反映出结点之间的逻辑关系，这样既能够最大可能地节省存
zwangZJU#LeetCode-in-python-wznote#LeetCode-python-104-二叉树的最大深度1
07-25
示例解题思路最大的深度是左子树或右子树中深度中更大的一个+1，递归的在子树的子树中寻找代码实现Definition for a binary tree node
leetcode答案-LeetCode-solution:LeetCode-解决方案
06-30
104,二叉树的高度,其DFS和BFS的迭代写法还需要再深入研究…… 2017/11/11 光棍节还在刷题，没办法，10号在写自传…… 新增了690，DFS开始得心应手了…… 2017/12/13 爆炸，居然一个月了…新增695，于是我果然还是...
leetcode答案-leetcode-:leetcode-
06-30
二叉树最小深度 思路 就左右两边找然后递归。 开始没有考虑到无根情况，导致一直是段错误 code class Solution { public: int run(TreeNode *root) { if(!root) return 0; if (root->left==NULL && root->right==...
寻找主元素leetcode-LeetCode-Problems:LeetCode-问题
06-30
二和 2. 字符串中的第一个唯一字符 3. 有序数组的平方 4. 从排序数组中删除重复项 5. 查找数组中所有消失的数字 6. 查找数组中的所有重复项 7. 多数元素 8. 最大连续数 9. 截留雨水 10. 第 N 个 Tribonacci 数 11. ...
leetcode浇花-Leetcode-Problems:Leetcode-问题
07-01
leetcode 浇花Leetcode-问题 Leetcode 玩具问题的日常解决方案 #3. 没有重复字符的最长子串#2。 添加两个数字 #7。 反转整数 #9。 回文数#11。 装有最多水的容器 #14。 最长公共前缀 #15。 3总和#16。 3Sum 最近的 #...
maycope#Leetcode-Classic#1.5 二叉树是否平衡1
07-25
1.5 二叉树是否平衡Given a binary tree, determine if it is height-balanced.For this prob
itcharge#LeetCode-Py#剑指 Offer 55 - I. 二叉树的深度1
07-25
剑指 Offer 55 - I. 二叉树的深度标签：树、深度优先搜索、广度优先搜索、二叉树难度：简单题目大意给定一个二叉树的根节点 root。深度：从根节点到叶
lrucacheleetcode-leetcode-practice:Leetcode-练习
06-29
二叉树右侧视图（DFS和BFS）中 岛屿数量 - BFS、联合和查找媒介 子集 - 位操作介质 K 最近点到原点 - 堆 有效的二叉搜索树中 BST：对于当前节点，左子树最大节点值< node.val < 右子树最小节点值235.二叉搜索...
leetcode信封-LeetCode-QA:LeetCode-QA
06-30
验证二叉树的前序序列化 中等 338 比特位计数 中等 354 俄罗斯套娃信封问题 困难 503 下一个更大元素 II 中等 706 设计哈希映射 简单 1047 删除字符串中的所有相邻重复项 简单 1629 按键持续时间最长的键 简单 1779
第五章 二叉树与图
Stay Hungry Stay Foolish 求知若饥 虚心若愚
07-18 955
文章目录二叉树与图leetcoe例1：路径之和（113）例2：最近的公共祖先（236）例3：二叉树转链表（114）例4：侧面观察二叉树（199）例5：课程安排（有向图判断环）（207）剑指offer 二叉树与图 简介 树是n（n>=0）个节点的有限集，且这些节点满足如下关系： 有且仅有一个结点没有父结点，这些结点称为树的根。 除根外，其余每个结点都有且近有一个父结点。 树中的每个结点都构成...
二叉树的存储结构
雨潇的博客
11-17 475
学习反思： 二叉树学习到现在基本上告一段落了，老师的进度已经完成，剩下的就是我们自己的事情了，比如好好复习，做完剩下的练习题目。 对于我还没有做出来的那个练习题，我心中其实只有一点点想法，比如说在交换的时候变化指向左右子树的指针，但是这个过程是个递归的过程，如何把握使两个节点只交换一次，应该是需要考虑的内容之一……吧？还有就是怎么交换指针，需要交换的是这个节点的两个子节点，应该可以参考单链的操...
将二叉树转化为图结构
qq_43799909的博客
07-26 729
本函数（见下述代码）能够实现将二叉树（最小节点数为1）转为图结构，是在做题的过程中用的一个函数，在这里发出来当个笔记吧。
二叉树和图的遍历算法详解
JE_9664的博客
09-02 1227
线性表可以看成是一对一的关系，树为一对多的关系，而图则是最为复杂的多对多关系。而之所以把树和图放在一起讲解，主要是因为它们都具有一对多的特点，那么在一定程度上，其遍历过程就都可以按照宽度优先和深度优先的形式去进行。
leetcode 二叉树
最新发布
09-16
二叉树是一种特殊的数据结构，它由节点组成，每个节点最多有两个子节点。在LeetCode上，二叉树问题是常见的算法题型，我们需要实现各种操作，如合并树、找出深度、遍历等。 在引用中，给出了一个合并二叉树的解法。该解法使用递归的方式将两棵二叉树合并为一棵新的二叉树。首先判断两棵树是否为空，如果其中一棵为空，就返回另一棵树。然后将两棵树的节点值相加，更新合并后的树的节点值。接着递归地合并左子树和右子树。最后返回合并后的树。 在引用中，介绍了如何找出二叉树的最大深度。该问题可以通过递归的方式来解决。如果树为空，深度为0；否则，深度等于左子树的最大深度和右子树的最大深度中的较大值加1。 在引用中，给出了判断二叉树是否平衡的解法。一个平衡二叉树是指其左右子树的高度差不超过1。该解法使用递归的方式判断每个节点的左右子树是否平衡，并通过引用变量返回当前树的高度。如果左右子树都平衡且高度差不超过1，则当前树为平衡二叉树。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值