数据结构与算法-树与图
往期内容
1-链表
2-栈与队列
3-树与图
4-哈希表
5-查找
6-排序
7-贪心
8-递归与分治
9-动态规划
基本概念
树：一对多的存储结构
一、树基本概念
树的表示方法
1.1 树的表示方法
-
双亲表示法
-
孩子表示法
-
双亲孩子表示法
-
孩子兄弟表示法
//树的存储结构
//树的存储结构--顺序存储结构
//1.双亲表示法
//约定：根结点的位置域设置为-1
//优点：很容易找到节点的双亲，不容易找到节点的孩子节点，解决方法-> 增加一个孩子域firstchild和rightsib右兄弟域
#define MAX_TREE_SIZE 100
typedef int TElemType;
struct PTNode
{
TElemType data;//当前节点的数据
int parent;//当前节点的双亲节点的位置
};
struct PTree
{
PTNode nodes[MAX_TREE_SIZE];//节点数组
int r,n;//根的位置，节点数目
};
//2.孩子表示法
//方案一：按照最大的度来开辟数据域和孩子域
//方案二：专门取一个位置来存储结点指针域的个数->克服空间浪费的缺点，空间的利用率提高，但是每个结点链表的结构不同，导致时间上会带来一定的损耗
//方案三：孩子表示法->把每个结点放到一个顺序存储的数组中，然后对每个孩子结点建立单链表->很容易找到节点的孩子节点，或者某个节点的兄弟结点，双亲难
// ------>解决方式：增加一个结构变量parent，用于存储结点的双亲信息
typedef struct CTNode//孩子结点
{
int child;
CTNode *next;
} *ChildPtr;
typedef struct//表头结点
{
TElemType data;
ChildPtr firstchild;
}CTBox;
typedef struct //树结构
{
CTBox nodes[MAX_TREE_SIZE];//结点数组
int r,n;//根节点位置，根节点的数目
}CTree;
//3.孩子兄弟表示法
//结点的结构：data-firstchild-rightsib
//同样不方便找到双亲，可以利用增加parent指针的方式解决
typedef struct CSNode
{
TElemType data;//数据域
CSNode *firstchild,*rightsib;//左孩子，右兄弟指针
}CSNode,*CSTree;
1.2 二叉树的表示
//二叉树
//满二叉树是理想型的完全二叉树
//完全二叉树：按照层序的编号，相同的结点一一对应，
/**************************************************完全二叉树的特点*********************************************/
/*
1.叶子结点只能出现再最下面两层
2.某个结点度为1，只有左孩子，没有右孩子
3.同样结点数的二叉树，完全二叉树的深度最小
*/
/**************************************************完全二叉树的性质*********************************************/
/*
见《大话数据结构》p169
*/
//二叉树的存储结构
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
1.3 二叉树的常用性质
性质1：二叉树第i层 至多有2^(i-1)个结点
性质2：有k层深度的二叉树，至多共有2^k-1个结点
性质3：对任何一个二叉树T，终端结点数为n1，度为2的结点数为n2，则n1=n2+1
性质4：n个结点完全二叉树的深度为[logn]+1,向下取整
性质5：
二、二叉树基本操作
2.1 前中后遍历
- 前序遍历
//前序遍历：根->左->右
void PreOrderTraverse(BiTree T)
{
//1.退出条件
if (T == NULL)
return;
//2.先取出数据
cout << T->data;
//3.依次遍历左右子树
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
- 中序遍历
//中序遍历：左->根->右
void InOrderTraverse(BiTree T)
{
//1.退出条件
if (T == NULL)
return;
//2.遍历左子树
InOrderTraverse(T->lchild);
//3.取出数据
cout << T->data;
//4.遍历右子树
InOrderTraverse(T->rchild);
}
- 后续遍历
//后续遍历：左->右->根
void PostOrderTraverse(BiTree T)
{
//1.退出条件
if (T == NULL)
return;
//2.遍历左子树
PostOrderTraverse(T->lchild);
//3.遍历右子树
PostOrderTraverse(T->rchild);
//4.取出数据
cout << T->data;
}
2.2 线索二叉树
//线索二叉树->中序遍历，将所有空指针域的右孩子结点指向它的后继结点，左孩子节点指向前驱结点
//解决问题：普通的二叉树，再叶子结点上，会产生较多的空指针域。造成资源的浪费
//核心：1.遍历进行线索化，将空的指针域指向下一个遍历的结点
//线索二叉树的实质，是将一颗二叉树变成了一个双向链表
#include<iostream>
using namespace std;
#define TElemType char
//显示二叉树的结构：lchild-ltag(左孩子or前驱标志位)-data-rtag-rchild
typedef enum{Link,Thread} PointerTag;//Link==0表示左右孩子指针，Thread==1表示前继或者后继的线索
typedef struct BiThrNode
{
TElemType data;
BiThrNode *rchild,*lchild;
PointerTag LTag;
PointerTag RTag;
}BiThrNode,*BiThrTree;
//线索化的过程：在遍历的时候修改空指针的指向
BiThrTree pre;//始终指向刚刚访问过的结点
void InThreading(BiThrTree p)
{
if(p)//如果当前结点不为空
{
//对左空孩子指针操作
InThreading(p->lchild);
if(!p->lchild)//当前结点
{
p->LTag=Thread;//前驱线索
p->lchild=pre;//指向刚刚访问过的结点
}
if(!pre->lchild)//前驱没有孩子
{
pre->RTag=Thread;//后继线索
pre->rchild=p;//指向刚刚访问过的结点
}
pre=p;//pre保持始终指向p的前驱
//对右边空孩子指针操作
InThreading(p->rchild);
}
}
2.3 树、二叉树、森林转换
参考：三者转换
三、图的基本概念
3.1 邻接矩阵
利用二维数组来表示图，一维度数组中存储图中顶点信息，二维数组中存储图中的边或弧的信息
- 定义
typedef char VertexType;//用户定义的顶点类型
typedef int EdgeType;//边上的权值类型
#define MAXVEX 100//用户定义的最大顶点数
#define INFINITY 65535//用INFINITY表示不连通的边
typedef struct{
VertexType vexs[MAXVEX];//顶点集合
EdgeType arc[MAXVEX][MAXVEX];//用邻接矩阵表示边的集合
int numVertex,numEdges;//图中当前的顶点数和边数
}MGraph;
- 初始化
//建立无向图的邻接矩阵表示
void CreateMGraph(MGraph *G)
{
int i,j,k,w;
cout<<"请输入顶点数和边数"<<endl;
cin>>G->numVertex;
cin>>G->numEdges;
cout<<"输入顶点的值";
for(i=0;i<G->numVertex;i++)
{
//输入顶点信息
cin>>G->vexs[i];
}
//初始化邻接矩阵表为空表
for(i=0;i<G->numVertex;i++)
{
for(j=0;j<G->numVertex;j++)
{
G->arc[i][j]=INFINITY;
cout<<G->arc[i][j]<<" ";
}
cout<<endl;
}
cout<<"边数"<<G->numEdges<<endl;
//填入边的信息
for(k=0;k<G->numEdges;k++)
{
cout<<"请输入边的信息(i,j,w)"<<endl;
cin>>i;
cin>>j;
cin>>w;
G->arc[i][j]=w;
//对称矩阵
G->arc[j][i]=G->arc[i][j];
}
}
3.2 邻接表
- 定义
//2.邻接矩阵缺点->当边数相对顶点数小的时候，这种方法对存储空间会产生极大的浪费
//邻接表
//顶点用一位数组存储
//图中每个顶点vi的所有邻接点构成一个线性表
//边表结点
typedef struct EdgeNode{
int adjvex;//用于存储该顶点对应的下标
EdgeType weight;//边的参数
EdgeNode *next;//指向下一边结点的指针域
}EdgeNode;
//顶点表结点
typedef struct VertexNode{
VertexType data;//数值域
EdgeNode *firstedge;//指向边结点的指针域
}VertexNode,AdjList[MAXVEX];
//邻接表
typedef struct{
AdjList adjList;//顶点的（数组）
int numVertexes,numEdges;//当前图中的顶点数和边数
}GraphAdjList;
- 创建
//用邻接表创建图
void CreateALGraph(GraphAdjList *G)
{
int i,j,k;
//定义边结点
EdgeNode *e;
cout<<"输入当前图的顶点数和边数"<<endl;
cin>>G->numVertexes>>G->numEdges;
cout<<"输入顶点的值";
//建立顶点表
for(int i=0;i<G->numVertexes;i++)
{
cin>>G->adjList[i].data;//输入顶点表的数据
G->adjList[i].firstedge=NULL;//初始顶点表的下一指针为空
}
//边表
for(k=0;k<G->numEdges;k++)
{
cout<<"请输入边(vi,vj)上的顶点序号"<<endl;
cin>>i>>j;
//申请边顶点的空间
e=(EdgeNode*)malloc(sizeof(EdgeNode));
e->adjvex=j;//邻接序号为j
//头插法写法
e->next=G->adjList[i].firstedge;
G->adjList[i].firstedge=e;
//无向表要书写相同的两次
e=(EdgeNode*)malloc(sizeof(EdgeNode));
e->adjvex=i;//邻接序号为i
//头插法写法
e->next=G->adjList[j].firstedge;
G->adjList[j].firstedge=e;
}
}
void printGraphAdjList(GraphAdjList G)
{
int i,j;
EdgeNode* p;
for(i=0;i<G.numVertexes;i++)
{
//打印顶点表的值
cout<<G.adjList[i].data<<" ";
p=G.adjList[i].firstedge;
while(p!=NULL)
{
//打印边结点的值
cout<<G.adjList[p->adjvex].data<<" ";
p=p->next;
}
cout<<endl;
}
}
3.3 边集数组
顶点数组
边数组 begin end weight
四、图的基本操作
4.1 深度优先遍历DFS
递归
1.定义一个visit数组，数组的大小与顶点表的长度一致，visit对应位置的值，表示该结点是否已经完成访问
2.依次循环遍历每一个顶点
3.访问当前结点，判断当前结点是否已经完成访问，如果访问，跳过该结点，否则将该结点对应的visit位置，置为访问状态，并进行递归遍历操作
- 邻接矩阵
bool visit[MAXVEX];//访问标志数组
//邻接矩阵的深度优先遍历的递归算法
void DFS(MGraph G,int i)
{
int j;
visit[i]=true;
cout<<G.vexs[i]<<" ";
for(j=0;j<G.numVertex;j++)
{
if(G.arc[i][j]!=INFINITY && visit[j]!=true)//找到邻接顶点，并且该顶点未被访问
DFS(G,j);
}
}
void DFSTraverse(MGraph G)
{
int i;
for(i=0;i<G.numVertex;i++)//初始化所有的元素未被访问
{
visit[i]=false;
}
for(i=0;i<G.numVertex;i++)
{
//如果未被访问
if(!visit[i])
DFS(G,i);
}
}
- 邻接表
//邻接表的深度优先遍历的递归算法
void DFS(GraphAdjList G,int i)
{
EdgeNode *p;
cout<<G.adjList[i].data;
visit[i]=true;
p=G.adjList[i].firstedge;
while(p)
{
if(!visit[p->adjvex])
DFS(G,p->adjvex);
p=p->next;
}
}
void DFSTraverse(GraphAdjList G)
{
int i;
for(i=0;i<G.numVertexes;i++)//初始化所有的元素未被访问
{
visit[i]=false;
}
for(i=0;i<G.numVertexes;i++)
{
//如果未被访问
if(!visit[i])
DFS(G,i);
}
}
4.2 广度优先遍历BFS
/*********广度优先遍历************************/
bool visit[MAXVEX];
void BFSTraverse(MGraph G)
{
int i,j;
SqQueue Q;
InitQueue(&Q);//队列
for(i=0;i<G.numVertex;i++)
visit[i]=false;
for(i=0;i<G.numVertex;i++)
{
if(!visit[i])
{
visit[i]=true;
cout<<G.vexs[i];//输出当前的结果
EnQueue(&Q,i);//将i压入队列中,只要访问过的顶点都压入队列中
while(Q.front!=Q.rear)//如果队列不为空
{
DeQueue(&Q,&i);//取出当前队列中的数据并赋值为i
for(int j=0;j<G.numVertex;j++)
{
if(G.arc[i][j]!=INFINITY && !visit[j])
{
visit[j]=true;
cout<<G.vexs[j];
EnQueue(&Q,j);
}
}
}
}
}
}
/*****广度优先遍历-邻接************/
void BFSTraverse(GraphAdjList G)
{
int i,j;
SqQueue Q;
InitQueue(&Q);//队列
EdgeNode *p;
for(i=0;i<G.numVertexes;i++)
visit[i]=false;
for(i=0;i<G.numVertexes;i++)
{
if(!visit[i])
{
visit[i]=true;
cout<<G.adjList[i].data;//输出当前的结果
EnQueue(&Q,i);//将i压入队列中,只要访问过的顶点都压入队列中
while(Q.front!=Q.rear)//如果队列不为空
{
DeQueue(&Q,&i);//取出当前队列中的数据并赋值为i
p=G.adjList[i].firstedge;
while(p)
{
if(!visit[p->adjvex])
{
visit[p->adjvex]=true;
cout<<G.adjList[p->adjvex].data;
EnQueue(&Q,p->adjvex);
}
p=p->next;
}
}
}
}
}
4.3 最小生成树
最小生成树->最小的带权无向图
最小生成树：对于无向连通图G=(V,E),G的所有的生成树当中，边的权值之和最小的生成树为G的最小生成树（MST）
所有边的权值都不相同，则最小生成树是唯一的，或者n个节点只有n-1条边，最小生成的边数是顶点数减一
4.3.1普利姆算法
参考博文
最小生成树
普利姆（Prlm）
- ①从图中找第一个起始顶点v0，作为生成树的第一个顶点，然后从这个顶点到其他顶点的所有边中选一条权值最小的边。然后把这条边的另一个顶点v和这条边加入到生成树中。
- ②对剩下的其他所有顶点，分别检查这些顶点与顶点v的权值是否比这些顶点在lowcost数组中对应的权值小，如果更小，则用较小的权值更新lowcost数组。
- ③从更新后的lowcost数组中继续挑选权值最小而且不在生成树中的边，然后加入到生成树。
- ④反复执行②③直到所有所有顶点都加入到生成树中。
概要:
双重循环，外层循环次数为n-1，内层并列的两个循环次数都是n。故普利姆算法时间复杂度为O(n2)
而且时间复杂度只和n有关，所以适合稠密图 - ⑤ 切记：adjvex数组：(i,adhvex[i])表示一条边。lowcost[i]表示当前(i,adhvex[i])的最小距离
/************************************************Prim算法的最小生成树*****************************************/
//prim：
//算法定义：
/*
无向连通图G=(V,E)
假设N=(P,{E})是连通图，TE是N上最小生成树中边的集合。
算法从U={u0},(u0∈V),TE={}开始。重复执行如下的操作：------->U是新加入的顶点集合，V是原始的顶点集合
在所有u∈U,v∈V-U的边(u,v)∈E中找到一条代价最小的边(u0,v0)并入集合TE,同时V0并入U，直至U=V为止。
此时TE中必有n-1条边，则T=(V,{te})为N的最小生成树。
*/
void MiniSpanTree_Prim(MGraph G)
{
int adjver[MAXVEX];//保存相关的顶点下标
int lowcost[MAXVEX];//记录顶点间边的权值
lowcost[0]=0;//存放这U中的原始到所有结点的最小值
adjver[0]=0;//存放这边信息，即索引和该索引里面的值构成了边。adjver[0]=0,第一个位置不存放值，因此有n-1条边
for(int i=0;i<G.numVertex;i++)//初始化lowcost数组存放第一行邻接矩阵的值，初始话adjer边矩阵的所有值为0
{
lowcost[i]=G.arc[0][i];
adjver[i]=0;
}
int min_arc;//用于找到lowcost数组中的最小值，默认为最大值
int min_vex;//最小的边（adjver[min_vex],min_vex）
for(int i=1;i<G.numVertex;i++)//表示需要循环的次数n-1,如果有n个结点的话
{
min_arc=INFINITY;//默认最小的值为一个很大的数
for(int j=1;j<G.numVertex;j++)
{
if(lowcost[j]!=0 && lowcost[j]<min_arc)//在所有u∈U,v∈V-U的边(u,v)∈E中找到一条代价最小的边(u0,v0)并入集合TE
{
min_arc=lowcost[j];//将当前最小的值保存在min_arc中
min_vex=j;
}
}
lowcost[min_vex]=0;
cout<<"最小的权值中最小的边"<<"("<<adjver[min_vex]<<","<<min_vex<<")"<<endl;
//循环其他的点，并将其他的点加入进来
for(int j=0;j<G.numVertex;j++)
{
if(lowcost[j]!=0 && G.arc[min_vex][j]<lowcost[j])
{
lowcost[j]=G.arc[min_vex][j];//更新lowcost的值，是的U中的所有点，到每个结点的值最小
adjver[j]=min_vex;//表示是谁（min_arc）使得j位置上lowcost最小的?,故
}
}
}
}
4.3.2 克鲁斯卡尔算法
将图中边按照权值从小到大排列，然后从最小的边开始扫描，设置一个边的集合来记录，如果该边并入不构成回路的话，则将该边并入当前生成树。直到所有的边都检测完为止。
概要:
概要: 克鲁斯卡尔算法操作分为对边的权值排序部分和一个单重for循环，它们是并列关系，由于排序耗费时间大于单重循环，所以克鲁斯卡尔算法的主要时间耗费在排序上。排序和图中边的数量有关系，所以适合稀疏图
/************************************************Kruskal算法的最小生成树*****************************************/
//Kruskal：
//算法定义：
/*
假设N={V,{E}}是连通图，令最小生成树的初始状态只有n个结点，没有边，结果集合中，初始化为T={V,{}},假设刚开始每个图中的顶点单独存在
在E中选择代价最小的边，若该边依附的顶点落在T中不同的连通分量上（新加入的边没有构成环），则将此边加入到T中，
否则舍去此边，寻找下一个代价最小的边
依次类推，直到T中所有的顶点都在同一个连通分量上为止。
*/
//定义一个边集数组结构
typedef struct{
int begin;
int end;
int weight;
}Edge;
//将图转化为排序好后的边集数组
/* 交换权值 以及头和尾 */
void swapn(Edge *edges, int i, int j)
{
int temp;
temp = edges[i].begin;
edges[i].begin = edges[j].begin;
edges[j].begin = temp;
temp = edges[i].end;
edges[i].end = edges[j].end;
edges[j].end = temp;
temp = edges[i].weight;
edges[i].weight = edges[j].weight;
edges[j].weight = temp;
}
/* 对权值进行排序 */
void sort(Edge edges[], MGraph *G)
{
for(int i = 0; i < G->numEdges; i++)//简单选择排序
{
for(int j = i + 1; j < G->numEdges; j++)
{
if(edges[i].weight > edges[j].weight)
swapn(edges, i, j);
}
}
cout<<"排序后的边集数组为:\n";
for (int i = 0; i < G->numEdges; i++)
{
cout<<edges[i].begin<<" "<<edges[i].end<<" "<<edges[i].weight<<endl;
}
cout<<"------------------------------------------------------"<<endl;
}
//查找连接线顶点的尾部下标
int find(int *parent,int f)
{
while(parent[f]>-1)//只要父节点不为-1，一直向上查找，直到找到父节点为止，如果为-1，则将该结点作为父结点
f=parent[f];
return f;
}
void MiniSpanTree_Kruskal(MGraph G)
{
//定义一个边集数组
Edge edge[MAXVEX];
//定义一个并查集
int parent[MAXVEX];//用于判断是否构成了回路
//G转换为排序好的边集数组，并排序
/* 用来构建边集数组并排序********************* */
int k=0;
for(int i = 0; i < G.numVertex - 1; i++)
{
for(int j = i + 1; j < G.numVertex; j++)
{
if(G.arc[i][j] < INFINITY)
{
edge[k].begin = i;
edge[k].end = j;
edge[k].weight = G.arc[i][j];
k++;
}
}
}
sort(edge, &G);
/* ******************************************* */
//初始化上述的两个数组
for(int i=0;i<G.numVertex;i++)
{
parent[i]=-1;
}
for(int i=0;i<G.numEdges;i++)//遍历所有的边
{
int n=find(parent,edge[i].begin);//找到edge[i].begin的父结点
int m=find(parent,edge[i].end);//找到edge[i].end的父节点
if(n!=m)//现有的生成树，没有形成环
{
parent[n]=m;//将边加入集合中，m（end）为根，n（begin）为孩子
cout<<edge[i].begin<<" "<<edge[i].end<<" "<<edge[i].weight<<endl;
}
}
}
4.4 最短路径
4.4.1 迪杰斯特拉算法
/****************************************Dijkstra(迪杰斯特拉算法)**************************************/
//Dijkstra 带权图单元最短路径-》最终找到v0没其余顶点的最短路径
/*
辅助数组：dist[]:记录从源点v0到其他各个顶点当前的最短路径长度，数组中的值初始化为源点到各个顶点边的权值，即dist[i]=arcs[0][i]
s[]:标记已经计算完成的顶点。数组中的值全部初始化为0，源点下标初始化为1，计算完成赋值为1
path[]:记录从最短路径中顶点的前驱顶点，path[i]表示v到vi最短路径上vi的前驱顶点
*/
//见王道数据结构考研：核心(min+G.arc[min_vex][j])<dist[j]
void ShortestPath_Dijkstra(MGraph G,int v0)
{
int dist[MAXVEX];
int s[MAXVEX];
int path[MAXVEX];
for(int i=0;i<G.numVertex;i++)//初始化数据
{
s[i]=0;//0表示该结点未被访问，1表示该结点已经被访问
dist[i]=G.arc[v0][i];
path[i]=0;
}
//修改第一个数据的值
dist[v0]=0;
s[v0]=1;
int min;//寻找最小的值
int min_vex;//最小的边（adjver[min_vex],min_vex）
for(int i=1;i<G.numVertex;i++)//循环n-1次
{
min=INFINITY;
for(int j=0;j<G.numVertex;j++)
{
if(!s[j] && dist[j]<min)
{
min=dist[j];
min_vex=j;
}
}
s[min_vex]=1;//该顶点已被访问
//修正当前的最短路径和距离
for(int j=0;j<G.numVertex;j++)
{
if(!s[j] && (min+G.arc[min_vex][j])<dist[j])
{
dist[j]=min+G.arc[min_vex][j];
path[j]=min_vex;//j的父亲结点是min_vex
}
}
}
//算法到处结束，下面用于打印路径的代码
for(int i=0;i<G.numVertex;i++)
{
cout<<path[i]<<" ";
}
}
4.4.2 佛洛依德算法
/*****************************Floyd算法*************************************/
void ShortestPath_Floyd(MGraph G)
{
int A[MAXVEX][MAXVEX];
int P[MAXVEX][MAXVEX];
for(int i=0;i<G.numVertex;i++)
for(int j=0;j<G.numVertex;j++){
A[i][j]=G.arc[i][j];//初始化A-1数组,保存某一点到另一点的最短路径长度和
P[i][j]=j;//默认开始，每个点都指向自己
}
for(int k=0;k<G.numVertex;k++)//中间点k
for(int i=0;i<G.numVertex;i++)
for(int j=0;j<G.numVertex;j++)
{
if(A[i][j]>A[i][k]+A[k][j]){
A[i][j]=A[i][k]+A[k][j];
P[i][j]=P[i][k];//i->j的路径变为，i->k->j
}
}
//算法到此处结束，后面展示的是打印和显示
for(int i=0;i<G.numVertex;i++)
{
for(int j=0;j<G.numVertex;j++)
cout<<P[i][j]<<" ";
cout<<endl;
}
//最短路径的显示代码：以从v0到v8为例
for(int v=1;v<G.numVertex;v++)//打印v0到所有顶点的最短路径
for(int w=v+1;w<G.numVertex;w++)
{
//打印第一点的的路径
cout<<v<<"到"<<w<<"的权值大小为:"<<A[v][w]<<endl;
int k=P[v][w];
cout<<"path="<<v<<"->";
while(k!=w)
{
cout<<k<<"->";
k=P[k][w];
}
cout<<w<<endl;
}
cout<<endl;
}
查找路径：以0-8为例
p[0][8]=1;
p[1][8]=2;
p[2][8]=4;
p[4][8]=3;
p[3][8]=6;
p[6][8]=7;
p[7][8]=8;
路径：v0->v1->v2->v4->v3->v7->v8
4.5 拓扑排序
4.6 关键路径
五、Leetcode刷题
5.1 路径之和2
class Solution {
public:
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
vector<vector<int>> result;
vector<int> item;//模拟栈的操作
int sum=0;
generate(root,targetSum,sum,item,result);
return result;
}
void generate(TreeNode*root,int &targetSum,int sum,vector<int> &item,vector<vector<int>> &result)
{
if(!root)
return;
item.push_back(root->val);//先序：加入结点
sum=sum+root->val;
if(root->left==nullptr && root->right==nullptr && sum==targetSum)
{
result.push_back(item);
}
//遍历左子树
generate(root->left,targetSum,sum,item,result);
//遍历右子树
generate(root->right,targetSum,sum,item,result);
sum-=root->val;//左右子树遍历完成：弹出结点
item.pop_back();
}
};
5.2 二叉树的最近公共祖先
Leetcode-236 二叉树的最近公共祖先
思路：用一个vector模拟栈，存储待查找结点，vector中保存所有的父亲结点。最后遍历两个数组找到，公共的最近祖先。
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
vector<TreeNode*> path_a, path_b;
if (!get_path(root, p, path_a) || !get_path(root, q, path_b)) return nullptr;
int i = 1;
for (; i < path_a.size() && i < path_b.size(); i++) {
if (path_a[i] != path_b[i]) return path_a[i-1];
}
return path_a[i-1];
}
bool get_path(TreeNode* root, TreeNode* a, vector<TreeNode*>& path) {
if (!root) return false;
path.emplace_back(root);
if (root == a) return true;
if (get_path(root->left, a, path)) return true;
if (get_path(root->right, a, path)) return true;
path.pop_back();
return false;
}
};
5.3 二叉树转链表
Leetcode-114 二叉树展开为链表
思路1：比较low的方法，遍历所有的元素并保存在vector数组中，然后从新构建一个链表
思路2：递归的思想，将整个是抽象为一个根节点、左子树和右子树，当前步骤构建二叉树只需要，改变指向：根节点指向左子树，左子树的最右叶子节点指向根结点的右子树，重点：记录链表的尾部指针。
class Solution {
public:
void flatten(TreeNode* root) {
TreeNode* last=nullptr;
preorder(root,last);
}
void preorder(TreeNode* root ,TreeNode* &last)//关键信息：右子树的有结点
{
if(!root)
return;
//前序
if(root->left==nullptr && root->right==nullptr)//最小子问题，单个结点的处理
{
last=root;
return;
}
TreeNode *left=root->left;
TreeNode *right=root->right;
TreeNode *left_last=nullptr;
TreeNode *right_last=nullptr;
//中序
if(left)//左子树
{
preorder(left ,left_last);
root->left=nullptr;
root->right=left;
last=left_last;
}
if(right)
{
preorder(right ,right_last);
if(left_last){
left_last->right=right;
}
last=right_last;
}
//后续
}
};
5.4 二叉树的右示图
Leetcode-199 二叉树的右视图
思路：宽度优先搜索，利用一个pair数据结构保存 结点和结点所在的层数，根据层数依次替换结点，知道每层的最后一个结点保存在结果集合中。
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(depth==view.size())
{
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;
}
};
8799
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
