5.算法之二叉树与图

最新推荐文章于 2023-12-28 20:05:49 发布

CarmenIsOK

最新推荐文章于 2023-12-28 20:05:49 发布

阅读量267

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/CarmenIsOK/article/details/88868648

版权

算法专栏收录该内容

19 篇文章 0 订阅

订阅专栏

（一）二叉树的定义

树是(n>=0)个结点的有限集，且这些结点满足如下关系：
（1）有且仅有一个结点没有父结点，该结点成为树的根。
（2）除根外，其余的每个结点都有且仅有一个父结点。
（3）树中的每一个结点都构成一个以她为根的树。
二叉树在满足树的条件时，满足如下条件：
每个结点最多有两个孩子（子树），这两个子树有左右之分，次序不可颠倒。

113. 路径总和 II

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
说明: 叶子节点是指没有子节点的节点。
示例:
给定如下二叉树，以及目标和 sum = 22，
在这里插入图片描述
返回:

1.使用何种数据结构存储遍历路径上的结点？
2.在树的前序遍历是做什么？后序遍历时做什么？
3.如何判断一个节点为叶结点？当遍历到叶结点时应该做什么？

在这里插入图片描述
类似回溯法！

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<int>path;
        vector<vector<int>> result;
        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+=node->val;
        path.push_back(node->val);
        if(path_value==sum&&node->left==NULL&&node->right==NULL)
        {
            result.push_back(path);
        }
        preorder(node->left,path_value,sum,path,result);
        preorder(node->right,path_value,sum,path,result);
        path_value-=node->val;
        path.pop_back();
    }
};

236. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
在这里插入图片描述
示例 1:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。
在这里插入图片描述

1.从根结点遍历（搜索）至该结点，找到该结点后就结束搜索。
2.将遍历过程中遇到的结点按照顺序存储起来，这些结点即路径结点。

求两路径上最后一个相同的结点。
1.求出较短路径的长度n。
2.同时遍历p结点的路径与q结点的路径，遍历n个结点，最后一个发现的相同结点，即最近公共祖先。

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        vector<TreeNode*> path;
        vector<TreeNode*> node_p_path;
        vector<TreeNode*> node_q_path;
        int finish=0;
        preorder(root,p,path,node_p_path,finish);
        path.clear();
        finish=0;
        preorder(root,q,path,node_q_path,finish);
        int path_len=node_p_path.size()<node_q_path.size()?node_p_path.size():node_q_path.size();
        TreeNode *result=NULL;
        for(int i=0;i<path_len;i++)
        {
            if(node_p_path[i]==node_q_path[i])
                result=node_p_path[i];
        }
        return result;
    }
    
private:
    void preorder(TreeNode* node,TreeNode *target,
                  vector<TreeNode*>&path, vector<TreeNode*>& result,int&finish)//先序遍历
    {
        if(!node||finish)
            return;
        
        path.push_back(node);
        if(node==target)
        {
            finish=1;
            result=path;
        }
        
        preorder(node->left,target,path,result,finish);
        preorder(node->right,target,path,result,finish);
        path.pop_back();
    }    
};

114. 二叉树展开为链表

给定一个二叉树，原地将它展开为链表。
例如，给定二叉树
在这里插入图片描述
将其展开为：

class Solution {
public:
    void flatten(TreeNode* root) {
        TreeNode* last=NULL;
        preorder(root,last);
    }
    void preorder(TreeNode* node,TreeNode* &last)
    {
        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;//将该结点的last保存为左子树的last
        }
        if(right)//若有右子树，递归的将右子树转换为单链表
        {
            preorder(right,right_last);
            if(left_last)//若node找到左子树最后一个结点（即存在左子树）
            {
                left_last->right=right;
            }
            last=right_last;
        }
    }
};

二叉树的层次遍历

又称为宽度优先搜索，按照树的层次依次访问树的结点。层次遍历使用队列对遍历结点进行存储，先进入队列的结点，优先遍历拓展其左孩子与有孩子。

设置队列Q
将根节点push进Q
while(Q不为空)
{
	取出队列头部结点node
	对node访问
	将node的左、右孩子push进入队列
}

199. 二叉树的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例:
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:
在这里插入图片描述

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> view;
        queue<pair<TreeNode*,int> >Q;//宽度优先搜索队列<结点，层数>
        
        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;
    }
};

（二）图的定义

图（Graph）是由定点的有穷非空集合和定点之间边的集合组成，同行表示为G（V，E），其中G表示一个图，V是图G中顶点的集合，E是图G中边的集合。
图分无向图与有向图，根据图的边长，又可以分为带权图与不带权图。
在这里插入图片描述
图的构造与表示
邻接矩阵
其中1代表i->j相连，0代表不相连

邻接矩阵较为稀疏时，常用邻接表。

图的深度优先遍历

图的宽度优先遍历

207. 课程表

现在你总共有 n 门课需要选，记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？
示例 1:
输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:
输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
说明:
输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
提示:
这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
拓扑排序也可以通过 BFS 完成。
在这里插入图片描述

struct GraphNode
{
    int label;
    vector<GraphNode*> neighbors;
    GraphNode(int x):label(x){};
};
class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<GraphNode*> graph;//邻接表
        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);//课程2指向课程1
        }
        for(int i=0;i<graph.size();i++)
        {
            if(visit[i]==-1&&!DFS_graph(graph[i],visit))
            {
                return false;//如果结点没访问过，进行DFS，如果DFS遇到环，返回无法完成
            }
        }
        for(int i=0;i<numCourses;i++)
        {
            delete graph[i];
        }
        return true;
        
    }
private:
    //结点访问状态：-1没有访问过，0代表增在访问，1代表已完成访问
    bool DFS_graph(GraphNode *node,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)==false)//递归访问，发现有环
                {//在访问本身的发现邻接的结点就已经正在访问的 递归的时候那条路经上所有的visit都为0
                    return false;
                }
            }else if(visit[node->neighbors[i]->label]==false)//有环
            {//同上
                return false;
            }
        }
         visit[node->label]=1;
        return true;
    }
};

在这里插入图片描述
入度为0，则说明该门课程（即这个结点）不用依赖于任何一门课程或者它依赖的课程已经学完了，就将这个结点添加至队列，完成宽度搜索之后，所有点的入度都为0，则说明图无环。

蓝色说明正在搜索，红色说明入队列。

struct GraphNode
{
    int label;
    vector<GraphNode*> neighbors;
    GraphNode(int x):label(x){};
};
class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<GraphNode*> graph;
        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]++;
        }
        
        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]-=1;
                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;
    }
   
};

CarmenIsOK

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
5.算法之二叉树与图

（一）二叉树的定义树是(n>=0)个结点的有限集，且这些结点满足如下关系：（1）有且仅有一个结点没有父结点，该结点成为树的根。（2）除根外，其余的每个结点都有且仅有一个父结点。（3）树中的每一个结点都构成一个以她为根的树。二叉树在满足树的条件时，满足如下条件：每个结点最多有两个孩子（子树），这两个子树有左右之分，次序不可颠倒。路径总和 II给定一个二叉树和一个目标和，找到所...
复制链接

扫一扫

专栏目录