数据结构与算法之----图

1、图的初始化

#include "stdafx.h"
#include<iostream>
using namespace std;
const int INF=65535;
struct Graph
{
 int *vex;
 int **arc;
 int numEdges,numVexes;
};
void CreateGraph(Graph &G)
{
 
 cout<<"请输入定点数和边数"<<endl;
 cin>>G.numVexes>>G.numEdges;
 G.vex=new int[G.numVexes];//为指向数组的指针

 G.arc=new int*[G.numVexes];//为指针数组
 for(int i=0;i<G.numVexes;i++)
  G.arc[i]=new int[G.numVexes];

 cout<<"请输入顶点值"<<endl;
 for(int i=0;i<G.numVexes;i++)//初始化顶点
  cin>>G.vex[i];
 cout<<'\n';

 for(int i=0;i<(G.numVexes);i++)//初始化边集数组
 { for(int j=0;j<(G.numVexes);j++)
  { 
   if(i==j)
    G.arc[i][j]=0;
   else
   G.arc[i][j]=INF;
  }
 }

 cout<<"请输入边的下标v1,v2权值w"<<endl;; 
 int m=0,n=0,w=0;
 for(int a=0;a<(G.numEdges);a++)//注意这里的G.numEdges必须()起来，否则会出问题
 {    
  cin>>m>>n>>w;
  G.arc[m][n]=w; 
  G.arc[n][m]=w;
 }
}

int _tmain(int argc, _TCHAR* argv[])
{
 Graph G;
 CreateGraph(G);
 for(int i=0;i<G.numVexes;i++)
  cout<<G.vex[i];
 cout<<'\n';
 for(int i=0;i<G.numVexes;i++)
 { 
  for(int j=0;j<G.numVexes;j++)
   cout<<G.arc[i][j]<<' ';
  cout<<'\n';
 }
 delete G.vex;
 delete G.arc;
 return 0;
}

 

注意两点：

（1）这里的顶点数组和邻接矩阵均为指针，而邻接矩阵为指向数组的指针，一定要注意其初始化方式

（2）a<G.numVexes可能会出问题，所以记得打上()

 

2、图的遍历

2.1 深度优先遍历

void DFS(Graph &G,int i)
{
	cout<<G.vex[i]<<endl;
	G.visited[i]=true;
	for(int j=0;j<G.numVexes;j++)
	{
		if(G.arc[i][j]!=INF && (!G.visited[j]))
			DFS(G,j);
	}
}
void DFSTraverse(Graph &G)
{
	G.visited=new int[G.numVexes];
	for(int i=0;i<G.numVexes;i++)
		G.visited[i]=false;
	for(int i=0;i<G.numVexes;i++)
	{
		if(!G.visited[i])
			DFS(G,i);
	}

		
}

思想：

（1）对于每一个点，都要打印它，以及和它有连接的，且没有访问过的点。

（2）这样就用到递归，函数由两部分组成，一个是打印本节点，另外的任务是访问和它有关的节点

（3）递归主体，如果满足条件，那么就让它去执行下一个相连节点

（3）函数部分，一定要做的是先打印。

2.2 广度优先遍历

void BFSTraverse(Graph &G)
{
	G.visited=new int[G.numVexes];
	for(int i=0;i<(G.numVexes);i++)
		G.visited[i]=false;
	queue<int> Q;//这才是默认使用queue的方式，和vector的使用是一样的
	for(int i=0;i<G.numVexes;i++)
	{
		if(!G.visited[i]) 
		{
			cout<<G.vex[i]<<endl;//此处保证就算没有连接 也可以打印出来
			G.visited[i]=true;
			Q.push(i);
			while(Q.size())//递归都可以拆解成while循环来搞定，这个方法好，利用队列
			{
				i=Q.front();
				Q.pop();
				for(int j=0;j<G.numVexes;j++)
				{
					if(G.arc[i][j]<INF && (!G.visited[j]))
						{
							cout<<G.vex[j]<<endl;
							G.visited[j]=true;
							Q.push(j);
						}

				}
			}
		}
	}

}

思想：

（1）将堆栈转化成队列来实现

（2）从理论上来讲，递归形成了堆栈，队列就可以不用做递归，真是太巧妙了。

（3）果然是这样的，以后要尝试用队列+while循环来解决所有递归的问题。

 

3、最小生成树

3.1 Prim算法 

<pre name="code" class="cpp">void MiniSpan_Prim(Graph &G)
{	
	int k=0;
	int *lowcost=new int[G.numVexes];
	int *adjvex=new int[G.numVexes];
	for(int i=0;i<G.numVexes;i++)
		lowcost[i]=INF;//lowcost初始化

	for(int i=1;i<G.numVexes;i++)//找出与顶点0相邻的顶点，并置lowcost
	{
		if(G.arc[0][i]<INF)
			lowcost[i]=G.arc[0][i];
	}
	lowcost[0]=0;
	for(int a=1;a<G.numVexes;a++)//找的次数
	{		
		int min=INF;
		for(int j=1;j<G.numVexes;j++)//找locost中最小的，标记下标
		{	
			if(lowcost[j]!=0 && lowcost[j]<min)
			{
				min=lowcost[j];
				k=j;
			}			
		}		

		lowcost[k]=0;//说明该点已经找过
		cout<<adjvex[k]<<" "<<k<<endl;
		for(int i=1;i<G.numVexes;i++)//从这一点触发，增加有权值的新点,需要和原来locost比较
		{
			if(lowcost[i]!=0 && G.arc[k][i]<locost[i])//此处为修改
				{
					lowcost[i]=G.arc[k][i];	
					adjvex[i]=k;//说明前一个点为k，这样就组成了一条边	
				}	
		}
	}
	//打印操作
	delete []lowcost;
}

思想：

（1）找到和0相邻的点，有一批lowcost值

（2）找出这批lowcost值中最小值对应的点。标记为已经找过，并打印

（3）找这个点相邻的点，加入到lowcost中，回到步骤2

（4）特点就是不断刷lowcost的值，省去了queue

4.1 克鲁斯卡尔算法(kruskal算法)

<pre name="code" class="cpp">#include "stdafx.h"
#include<iostream>
using namespace std;
const int INF=65535;
struct Edge
{
	int begin;
	int end;
	int weight;
};
struct Graph
{
 int *vex;
 Edge *edges; 
 int numEdges,numVexes;
};

void CreateGraph(Graph &G)
{
 
 cout<<"请输入顶点数和边数"<<endl;
 cin>>G.numVexes>>G.numEdges;
 G.vex=new int[G.numVexes];//为指向数组的指针

 G.edges=new Edge[G.numEdges];
 cout<<"请从小到大输入边"<<endl;
 for(int i=0;i<G.numEdges;i++)
 {
	 cin>>G.edges[i].begin>>G.edges[i].end>>G.edges[i].weight;
 }

}

int find(int *parent,int f)
{
	while(parent[f]>0)
		f=parent[f];
	return f;
}
void MiniSpaceTree_Kruskal(Graph &G)
{
	int m,n;
	int *parent=new int[G.numEdges]();
	for(int i=0;i<G.numEdges;i++)
	{
		n=find(parent,G.edges[i].begin);
		m=find(parent,G.edges[i].end);
		if(m!=n)
		{	
			parent[n]=m;//此处为修改后的
			cout<<G.edges[i].begin<<" "<<G.edges[i].end<<" "<<G.edges[i].weight<<'\n';
		}
	}
	delete []parent;//注意数组的释放
}

int _tmain(int argc, _TCHAR* argv[])
{
 Graph G;
 CreateGraph(G);
 MiniSpaceTree_Kruskal(G);
 delete []G.vex;
 delete []G.edges;
 return 0;
}

输出：

请输入定点数和边数
4 5
请从小到大输入边
0 1 1
2 3 1
1 2 2
1 3 2
0 2 3

0 1 1
2 3 1
1 2 2
Press any key to continue

 思想：

（1）顶点输入序号必须是要按照从小到大输入，小的在前面

（2）边必须按照由小到大输入，这样才能是最小生成树

（3）不断加入稍微长的，由小端标记可以达到的大端。 如果已经标记，那么大端标记为小端，这样就能够从联通的一点找到另外一点。

（4）若加入的边，不构成回路，那么记下这条边。

（5）其中find函数这种找法很不错。

5、最短路径算法

5.1 Dijkstra算法

<pre name="code" class="cpp"><pre name="code" class="cpp">#include<iostream>
using namespace std;
const int INF=65535;
struct Graph
{
int *vex;
int **arc;
int numEdges,numVexes;
};
void CreateGraph(Graph &G)
{ 
}
void ShortestPath_Dijkstra(Graph G,int v0,int *shortvalue,int *adjvex)
{
	bool *visited=new bool[G.numVexes];
	for(int i=0;i<G.numVexes;i++)
		visited[i]=false;
	visited[v0]=true;
	shortvalue[v0]=0;
	for(int i=0;i<G.numVexes;i++)
	{
		if(G.arc[v0][i]!=INF)
		{
			shortvalue[i]=G.arc[v0][i];
			adjvex[i]=v0;
		}

	}
	for(int i=1;i<G.numVexes;i++)//找当前最近的点
	{
		int min=INF;
		int k=0;
		for(int j=0;j<G.numVexes;j++)
		{
			if(!visited[j]&&shortvalue[j]<min)
				{
					min=shortvalue[j];
					k=j;
				}
		}
		for(int j=0;j<G.numVexes;j++)//对相邻的点最短距离，进行更新
		{
			if(!visited[j]&&min+G.arc[k][j]<shortvalue[j])
			{
				shortvalue[j]=min+G.arc[k][j];
				adjvex[j]=k;//标记其前一个点为k
			}
		}
	}
	delete []visited;
}

思想：

（1）对刚开始的点置为访问过，更新和它相邻的点的距离。

（2）每一次都要找出一个最近且没有找过的点，标记它并更新和它相连点的距离

（3）重复2

（4）找完之后shortvalue为各个点到它的距离，adjvex为要到这个点其前一个点的下标

5.2 弗洛伊德算法（Floyd）

其思想是：从v0,到v8可以通过不同的点来进行中转，比如说v0到v8可以通过1中转更近，而1到8则通过2更近，就这样迭代下去

有两个矩阵，一个是距离D,初始化为邻接矩阵。一个位中转矩阵P,初始化为目标的下标，如0到8刚开始只能通过8中转。

对于每一个中转点，都尝试通过它进行中转，若更近，则更新距离，且更新中转点。

第一层为k，通过每一个点进行中转

第二层为v,

第三层为w

if(D[v][w]>D[v][k]+D[k][w])
{
    D[v][w]=D[v][k]+D[k][w];
    P[v][w]=P[v][k];
}

6、拓扑排序

#include<iostream>
#include<stack>
using namespace std;
struct EdgeNode             //邻接表结构
{
	int adjvex;
	//int weight;
	EdgeNode *next;
};

struct VexNode
{
	int in;
	int data;
	EdgeNode *fistedge;
};
struct GraphList
{
	VexNode *adjlist;
	int numVexes,numEdges;
};
void CreateGraphList(GraphList &G)
{
	cout<<"请输入顶点和边的数目"<<endl;
	cin>>G.numVexes>>G.numEdges;
	G.adjlist=new VexNode[G.numVexes]();//直接初始化
	cout<<"请输入顶点的的data值"<<endl;
	for(int i=0;i<G.numVexes;i++)
	{
		cin>>G.adjlist[i].data;
	}
	cout<<"请输入边的出顶点，入顶点"<<endl;
	for(int i=0;i<G.numEdges;i++)
	{
		 int in,out;
		 cin>>in>>out;
		 EdgeNode *edge=new EdgeNode();
		 edge->adjvex=out;
		 edge->next=G.adjlist[in].fistedge;//利用前插法，这样就不需要遍历链表，而后插法需要先遍历到最后面才可以
		 G.adjlist[in].fistedge=edge;
		 //修改入度
		 G.adjlist[out].in++;
	}
	cout<<"显示输出效果"<<endl;
	for(int i=0;i<G.numVexes;i++)
	{
		 cout<<G.adjlist[i].in<<" ";//输出入度
		 EdgeNode *p=G.adjlist[i].fistedge;
		 while(p)
		 {
			cout<<p->adjvex;
			p=p->next;
		 }
		 cout<<'\n';
	}


}
void TopLogicalSort(GraphList &G)
{
	cout<<"输出拓扑排序"<<endl;
	stack<int> S;
	int count=0;
	for(int i=0;i<G.numVexes;i++)
	{
		if(G.adjlist[i].in==0)
		S.push(i);
	}
	while(S.size())
	{
		 int a=S.top();
		 S.pop();
		 count++;
		 cout<<"v"<<a<<" ";
		 EdgeNode *p=G.adjlist[a].fistedge;
		 while(p)
		 {
		if(!(--G.adjlist[p->adjvex].in))//注意是先-再使用
		S.push(p->adjvex);
		p=p->next;
		 }
	}
	if(count==G.numVexes)
	cout<<"TopLogicalSort ok"<<endl;
	else
	 cout<<"TopLogicalSort error"<<endl;
}
void DeleteOper(EdgeNode *edge)
{
	if(!edge) return;//注意当没有出度的情况
	else if(edge->next)
		DeleteOper(edge->next);
	else 
	 delete edge;
}
void DeleteGraphList(GraphList &G)
{
	for(int i=0;i<G.numVexes;i++)
	{
		DeleteOper(G.adjlist[i].fistedge);
	}
}
int main()
{
	GraphList G;
	CreateGraphList(G);
	TopLogicalSort(G);
	DeleteGraphList(G);
	system("pause");
}
int main()
{
	cout<<"hello"<<endl;
	system("pause");
}

输出：

请输入顶点和边的数目4 4请输入顶点的的data值0 1 2 3请输入边的出顶点，入顶点0 10 21 32 3显示输出效果0 211 31 32Press any key to continue

结构思想：

（1）创建邻接表需要建立3个结构，边结构，顶点结构，以及图的结构。

（2）先建立顶点数组，读入顶点值，后读入边，按照入度出度，修改顶点入度值，以及用前插法插入边，这里比后插方便太多了。

（3）删除表操作，这里还是用到递归，当然利用一个for函数对递归函数进行调用，因为这是不定次数的调用

（4）注意在递归体中注意当指针本身就为空的情况，这种情况下，需要直接返回。

（5）前插与后插的区别，前插用于链表，邻接表，而后插用于队列。

 

拓扑排序的作用：

拓扑排序对于一个工程的执行具有很好的指导意义，当然也可以应用于游戏开发中，一个项目中有很多个环节，一个环节需要在另外一个环节完成它才能完成，当有拓扑排序之后，就能够告诉你，先该做哪一步，再完成哪一步，按照拓扑排序出来，这样整个工程就能够执行完毕。

拓扑排序思想：

（1）压入入度为0的点

（2）不断出栈，打印顶点，并删掉出来的弧，将弧尾顶点入度减一，若入度变为0，则该顶点入栈（3）直到栈空

（4）遍历的时候一定要定义一个指针去遍历，否则会出问题，只能用while(p)或者while(p-next)，当然这里用while(p)

（5）注意--在前面和在后面的问题

7、关键路径

解决的是工程完成需要的最短时间问题，也就是关键路径。

如果只需要求关键路径，其实在拓扑排序里面讲其标出，找出最长的路径即可。这就相当于将dikstra算法做一下小小的修改即可。

但是这里如果那样的话，对于一个项目是没有什么帮助的，另外还需要知道，每一个活动的最早开始时间和最晚开始时间。

这样就能够安排，对每一个活动进行规划和了解。

其中点为事件，（）里面的为事件的最早发生时间和最晚发生时间。

要想判断每一个活动是否为关键路径，只需要用后一个事件的最晚发生时间-前一个时间的最早发生时间，判断是否相等即可。

事件的最早发生时间=前面所有活动的结束时间中的最大值，即（从前面不同事件出发+活动）中的最大值

事件的最晚发生时间=后面所有活动开始时间中的最小值，即（从后面不同事件出发-活动）中的最小值

活动的最早开始时间=事件最早发生时间

活动的最晚开始时间=活动结束后对应事件的最晚发生时间-工期

而

若两者相等，则该活动为关键路径。

另外：

一个活动的最早结束时间=最早开始时间+工期

一个活动的最晚结束时间=最晚开始时间+工期

void TopLogicalSortIn(GraphList &G,int *etv,stack<int> &S_I)
{
	cout<<"输出拓扑排序"<<endl;
	stack<int> S;
	int count=0;
	for(int i=0;i<G.numVexes;i++)
	{
		if(G.adjlist[i].in==0)
			S.push(i);
	}
	while(S.size())
	{
		int a=S.top();
		S.pop();
		S_I.push(a);//事件入栈
		count++;
		cout<<"v"<<a<<" ";
		EdgeNode *p=G.adjlist[a].fistedge;
		while(p)
		{
			if(!(--G.adjlist[p->adjvex].in))//
				S.push(p->adjvex);
			if((etv[a]+p->weight)>etv[p->adjvex])
				etv[p->adjvex]=etv[a]+p->weight;
			p=p->next;			
		}
	}
	if(count==G.numVexes)
	cout<<"TopLogicalSort ok"<<endl;
	else
		cout<<"TopLogicalSort error"<<endl;
}

void CriticalPath(GraphList &G)
{
	int *etv=new int[G.numVexes]();
	stack<int> S_I;
	TopLogicalSortIn(G,etv,S_I);
	cout<<endl;
	for(int i=0;i<G.numVexes;i++)
		cout<<etv[i]<<" ";

	//求ltv
	int *ltv=new int[G.numVexes];
	for(int i=0;i<G.numVexes;i++)//初始化
	{
		ltv[i]=etv[G.numVexes-1];
	}
	while(S_I.size())
	{
		int a=S_I.top();
		S_I.pop();
		EdgeNode *p;
		p=G.adjlist[a].fistedge;
		while(p)
		{
			int b=p->adjvex;
			int weight=p->weight;
			if(ltv[b]-weight < ltv[a])
				ltv[a]=ltv[b]-weight;
			p=p->next;

		}
	}

	cout<<endl;
	for(int i=0;i<G.numVexes;i++)
		cout<<ltv[i]<<" ";
	cout<<"关键路径是"<<endl;
	for(int i=0;i<G.numVexes;i++)//直接可以从开始去遍历了，不用从后面开始遍历
	{
		EdgeNode *p=G.adjlist[i].fistedge;
		while(p)
		{
			int b=p->adjvex;
			int weight=p->weight;
			if(etv[i]==(ltv[b]-weight))
				cout<<"("<<i<<","<<b<<")"<<weight<<" ";
			p=p->next;
		}
	}



	delete etv;
	delete ltv;

}

思想：

（1）利用拓扑排序将可行的顺序排好S_I（堆栈），并求出事件最早发生时间etv（求最大值）

（2）将所有事件的最晚发生时间初始化为整个项目发成的最早时间（etv(v-1)）。

（2）利用排好的反向顺序来读取事件，刚好从最后一个事件开始

（3）利用事件活动指向的下一个事件来确定当前事件的ltv（求最小值）

（4）遍历每一条边判断是否为关键路径（终点ltv-weight ==起点etv？？）