图的各种操作总结

#include "stdafx.h"
#include<iostream>
#include<math.h>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
#include<iomanip>
#include<stack>
#include <queue>
using namespace std;

#define MAXVEX 100
#define INFINIT 9999
//邻接矩阵数据结构定义
typedef struct
{
	int vertex[MAXVEX];
	int edge[MAXVEX][MAXVEX];
	int vexNum, arcNum;//顶点数和弧数
}MGraph;


//邻接表定义
typedef struct edgeNode//边表节点
{
	int adjVex;
	//int weight;//权值，可能不需要
	edgeNode *next;
}edgeNode;
typedef struct vexNode//顶点表节点
{
	int data;
	edgeNode *first;
}vexNode,adjList[MAXVEX];
typedef struct
{
	adjList list;
	int vexNum, arcNum;//顶点数和弧数
}graphAdjList;

int visited[MAXVEX] = { 0 };
void BFS(MGraph &g, int v);
void DFS(MGraph &g, int v);
//创建邻接矩阵的图
void createGraph1(MGraph &g,int isDigram)
{
	int i, j, w;
	int m, n;
	cout << "请输入顶点数和边数： " << endl;
	cin >> g.vexNum >> g.arcNum;
	cout << "请输入顶点名称： " << endl;
	for (i = 0;i < g.vexNum;i++)
	{
		cin >> g.vertex[i];
	}
	for (i = 0;i < g.vexNum;i++)
	{
		for (j = 0;j < g.vexNum;j++)
		{
			if (i == j)
				g.edge[i][j] = 0;
			else
				g.edge[i][j] = INFINIT;
		}
	}
	cout << "请输入边（vi, vj)的上标m，下标n和权值w: " << endl;
	for (i = 0;i < g.arcNum;i++)
	{
		cin >> m >> n >> w;
		g.edge[m][n] = w;
		if(isDigram==0)
			g.edge[m][n] = g.edge[n][m]=w;
	}
}
//创建临界表的图
void createGraph2(graphAdjList &g)
{
	int i,  w;
	int m, n;
	edgeNode *pe;
	cout << "请输入顶点数和边数： " << endl;
	cin >> g.vexNum >> g.arcNum;
	cout << "请输入顶点信息： " << endl;
	for (i = 0;i < g.vexNum;i++)//初始化顶点表
	{
		cin >> g.list[i].data;
		g.list[i].first = NULL;
	}
	for (i = 0;i < g.arcNum;i++)
	{
		cout << "请输入边（vi, vj)的上标m，下标n和权值w: " << endl;
		cin >> m >> n >> w;
		pe = new edgeNode();
		//pe->weight = w;
		pe->adjVex = n;
		pe->next = g.list[m].first;
		g.list[m].first = pe;

		pe = new edgeNode();
		pe->adjVex = m;
		pe->next = g.list[n].first;
		g.list[n].first = pe;
	}
}

//visit函数
void visit(int v)
{
	cout  << v << " ";
}
//邻接矩阵的深度优先遍历，递归实现
void DFSTraverse(MGraph g)
{
	int i;
	for (i = 0;i < g.vexNum;i++)
		visited[i] = 0;
	for (i = 0;i < g.vexNum;i++)//对每个联通分量调用一次dfs
		if (visited[i] == 0)
			DFS(g, i);
}
void DFS(MGraph &g,int v)
{
	visit(v);
	visited[v] = 1;
	for (int i = 0;i < g.vexNum;i++)
	{
		if ((g.edge[v][i] != 0) && (visited[i] == 0))
			DFS(g, i);
	}
}
//邻接矩阵的深度优先遍历，非递归实现
void DFS2(MGraph &g, int v)
{
	stack<int> s;
	visit(v);
	visited[v] = 1;
	
	s.push(v);
	while (!s.empty())
	{
		int  tempVex = s.top();//先不pop		
		int flag = 0;
		for (int i = 0;i < g.vexNum;i++)
		{
			if (g.edge[tempVex][i] != 0 && visited[i] == 0)
			{
				visit(tempVex);
				visited[tempVex] = 1;
				s.push(i);
				flag = 1;
				break;
			}
		}
		if (flag == 0)
		{
			s.pop();
		}
	}
}
//邻接矩阵广度优先遍历
void BFSTraverse(MGraph g)
{
	int i;
	for (i = 0;i < g.vexNum;i++)
		visited[i] = 0;
	for (i = 0;i < g.vexNum;i++)
		if (visited[i] == 0)
			BFS(g, i);
}
void BFS(MGraph &g, int v)
{
	queue<int> q;
	visit(v);
	visited[v] = 1;
	while (!q.empty())
	{
		int tempVex = q.front();
		q.pop();
		
		for (int i = 0;i < g.vexNum;i++)
		{
			if (g.edge[tempVex][i] != 0 && visited[i] == 0)
			{
				visit(tempVex);
				visited[tempVex] = 1;
				q.push(i);
			}			
		}
		
	}
}

//迪杰斯特拉算法
//有向图
void Dijkstra(MGraph & g)
{
	int vexNum = g.vexNum;
	int dist[MAXVEX];
	//误区0初始化只要一个{0}即可；9999初始化得用循环初始化
	for (int i = 0;i < MAXVEX;i++)
		dist[i] = INFINIT;
	//0表示在s中，1表示在v-s中
	int s[MAXVEX] = { 0 };
	int index = 0;
	int i;
	//inicialize
	s[0] = 1;
	index++;
	for ( i = 0;i < vexNum;i++)
	{
		dist[i] = g.edge[0][i];
	}
	while (index != vexNum)
	{
		int k,min=INFINIT;
		//search for the min vertex in (V-S)
		for (i = 1;i < vexNum;i++)
		{
			if (s[i] == 0)
			{
				if (dist[i] < min)
				{
					min = dist[i];
					k = i;
				}
			}
		}
		
		//add k to S
		s[k] = 1;
		index++;
		//change distinct
		for (i = 1;i < vexNum;i++)
		{
			if (s[i] == 0)
			{
				if (dist[i] > dist[k] + g.edge[k][i])
					dist[i] = dist[k] + g.edge[k][i];
			}
		}

	}
	//output
	for (i = 0;i < vexNum;i++)
		cout << dist[i] << " ";
	
}
int main()
{
	MGraph g;
	createGraph1(g,1);
	/*cout << "DFS递归： " << endl;
	DFSTraverse(g);cout << endl;
	cout << "DFS非递归： " << endl;

	cout << "BFS： " << endl;
	BFSTraverse(g);*/
	Dijkstra(g);
	
	
	int a;
	cin >> a;
}