(一)二叉树的定义
树是(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;
}
};