图的基本操作C++代码

创建图

邻接矩阵法：

//adjacency matrix邻接矩阵  ---------------------------------------------------------------------------------------
//vertex 顶点
#define MaxInt 32767
#define MVNum 100//最大顶点数


class AMGraph{
	public:
		char vex[MVNum];//顶点表
		int visit[MVNum];//是否访问过该顶点 
		int acm[MVNum][MVNum];//邻接矩阵
		int vexnum,edgenum;//顶点个数，边个数 
		queue<int> Q;
	public:
	//无向网 indirected net
	//图graph 
	AMGraph()
	{
		vexnum = 0;
		edgenum = 0;
	}
	void CreateIndirectedNet()
	{
		//顶点个数，边个数 	
		cout<<"顶点个数，边个数："<<endl; 
		cin >> vexnum >> edgenum; 
		//顶点表
		cout<<"输入顶点"<<endl;
		for(int i = 0;i < vexnum;i++)
			cin >> vex[i];
	//初始化邻接矩阵
		for(int i = 0;i < vexnum;i++)
		{
			for(int j = 0;j < vexnum;j++)
			acm[i][j] = 0;
		 } 
		 
	//输入两个点，以及他们的权值 
	//根据点找到下标，对应下标赋值 
		for(int k = 0;k < edgenum;k++)
		{
			char a,b;
			int weight;
			cout<<"输入每条边的两个顶点:"<<endl;
			cin >> a >> b;//图weight = 1
			int i = find_loc(a);
			int j = find_loc(b);
			acm[i][j] = 1;
			acm[j][i] = 1;//有向省去这个 
		}
	}	 
	

	int find_loc(char ch)//找某个顶点对应的下标
	{
		for(int i = 0;i < vexnum;i++)
		{
			if(ch == vex[i]) return i;
		}
		return -1;
	}
	
	//打印 
	void indnetprint()
	{
		for(int i = 0;i < vexnum;i++)
		{
			for(int j = 0;j < vexnum;j++)
			cout <<acm[i][j] <<" ";
			cout<<endl;
		 } 
	}
};

主函数：

	AMGraph G;
	G.CreateIndirectedNet();
	G.indnetprint();

运行结果：
输入部分：

输出：

邻接表法：

//adjacency list邻接表 -----------------------------------------------------------------------------------------------
typedef struct Node{
	int data;
	Node *next;
	Node(int i,Node *p)
	{
		data = i;
		next = p;
	}
}Node;//节点 
 
typedef struct Vex{
	char ch;
	Node *head;
}Verx[MVNum];//顶点数组

class ALGraph{
	public:
		Verx vex;
		int vexnum,edgenum;
	public:
		ALGraph()
		{
			vexnum = 0;
			edgenum = 0;
		}
		void CreateALGraph()
		{
			cout<<"顶点个数，边个数："<<endl;
			cin >> vexnum >> edgenum;
			cout<<"输入顶点"<<endl;
			for(int i = 0;i < vexnum;i++)
			{
				cin >> vex[i].ch;
				vex[i].head = NULL;
			}
			for(int k = 0;k < edgenum;k++)
			{
				char a,b;
				cout<<"输入两个顶点"<<endl; 
				cin >> a >> b;
				int i = find_loc(a);
				int j = find_loc(b);
				//插入j 
				Node *p = new Node(j,NULL);
				p->next = vex[i].head;
				vex[i].head = p;
				//插入i (有向直接插入j)
				Node *q = new Node(i,NULL);
				q->next = vex[j].head;
				vex[j].head = q;
			}
		}
		
		int find_loc(char ch)
		{
			for(int i = 0;i < vexnum;i++)
			{
				if(ch == vex[i].ch) return i;
			}
			return -1;
		}
		
		void print()
		{
			for(int i = 0;i < vexnum;i++)
			{
				cout<<i<<"和他们邻接: ";
				Node *p = vex[i].head;
				while(p!=NULL)
				{
					cout<<p->data<<" ";
					p = p->next;	
				} 
				cout<<endl;
			}
		}
}; 

主函数：

	ALGraph H;
	H.CreateALGraph();
	H.print();

测试结果：

图的搜索

在邻接矩阵中的搜索：
首先初始化visit数组

//在
	void init_visit()
	{
		for(int i = 0;i < vexnum;i++)
		{
			visit[i] = 0;
		 }
	}

DFS

	void DFS(int loc)//深度优先 
	{
		visit[loc]=1;//标记该点被访问 
		cout<<vex[loc]<<" ";//输出当前点的信息 
		for(int i = 0;i<vexnum;i++)//找出未访问过，且有连接的点 
		{
			if(acm[loc][i]!=0&&visit[i]==0)
			DFS(i);
		} 
	} 

BFS

这里我们使用队列保存每一行数据

	void BFS(int begin)
	{
		visit[begin] = 1;//最开始的点被访问，标记为1
		while(1)
		{
			int loc = Q.front();//取出队首元素
			Q.pop();//弹出队首元素
			cout<<vex[loc]<<" "; //输出队首元素
			for(int i = 0;i<vexnum;i++)//找出未访问过，且有连接的点 
			{
				if(acm[loc][i]!=0&&visit[i]==0)
				{
					Q.push(i);
					visit[i] = 1;
				}
			}
			if(Q.empty()) return ;
		} 
	}

主函数：

//DFS
    int begin;//指定从哪个点开始搜索
	cout<<"指定起点下标:"<<endl;
	cin >> begin;
	G.init_visit();//初始化，使得所有顶点未被访问过 
	G.DFS(begin);
//BFS
	cout<<endl;
	G.init_visit();//初始化，使得所有顶点未被访问过
	G.Q.push(begin);//最开始的点进入队列
	G.BFS(begin);

输入部分：

输出结果：（第一行为DFS(深度)搜索结果，第二行BFS（广度，一层一层的））


…未完待续