邻接矩阵-C++

原创 2015年11月18日 19:57:47
#include <iostream>
using namespace std;

struct Edge
{
	int start;
	int dest;
	int weight;
	friend ostream &operator<<(ostream &out,Edge &e);
};

ostream &operator<<(ostream &out,Edge &e)
{
	out<<"("<<e.start<<","<<e .dest<<","<<e .weight<<")";
	return out;
}

#include "Edge.h"
#include "SeqList.h"
#include <iostream>
using namespace std;

const int MAX_WEIGHT=9999;

template<class T>
class AdjMatrixGraph
{
public:
	AdjMatrixGraph(int size=10);
	AdjMatrixGraph(T vertice[],int vertCount,Edge edges[],int edgeCount);
	~AdjMatrixGraph();

	int vertexCount();
	T Get(int i);
	void insertVertex(T vertex);
	bool insertEdge(int i,int j,int weight);
	bool insertEdge(Edge edge);
	friend ostream &operator<<<T>(ostream &out,AdjMatrixGraph<T> &graph);
	bool removeEdge(int i,int j);
	bool removeVertex(int v,T &old);

private:
	SeqList<T> vertexList;
	int **adjmatrix;
	int size;
	int vertCount;
	void init(int size);
};

template<class T>
AdjMatrixGraph<T>::AdjMatrixGraph(int size)
{
	init(size);
}

template<class T>
void AdjMatrixGraph<T>::init(int size)
{
	this->size=size<10?10:size;
	this->adjmatrix=new int *[this->size];
	for(int i=0;i <this->size;i++)
	{
		this->adjmatrix[i]=new int[this->size];
		for (int j=0;j<this->size;j++)
		{
			this->adjmatrix[i][j]=(i==j)?0:MAX_WEIGHT;
		}
		this->vertCount=0;
	}
}

template<class T>
AdjMatrixGraph<T>::AdjMatrixGraph(T vertice[],int vertCount,Edge edges[],int edgeCount)
{
	init(vertCount);
	for (int i=0;i<vertCount;i++)
	{
		insertVertex(vertice[i]);
	}
	for (int j=0;j<edgeCount;j++)
	{
		insertEdge(edges[j]);
	}
}

template<class T>
AdjMatrixGraph<T>::~AdjMatrixGraph()
{
	for (int i=0;i<size;i++)
	{
		delete(adjmatrix[i]);
	}
	delete(adjmatrix);
}

template<class T>
int AdjMatrixGraph<T>::vertexCount()
{
	return vertCount;
}

template<class T>
T AdjMatrixGraph<T>::Get(int i)
{
	return vertexList.get(i);
}

template<class T>
ostream &operator<<(ostream &out,AdjMatrixGraph<T> &graph)
{
	out<<"顶点集合:"<<graph.vertexList<<"邻接矩阵:\n";
	int n=graph.vertCount;
	for (int i=0;i<n;i++)
	{
		for (int j=0;j<n;j++)
		{
			if (graph.adjmatrix[i][j]==MAX_WEIGHT)
			{
				out<<"∞ ";
			}
			else
			{
				out<<" "<<graph.adjmatrix[i][j]<<" ";
			}
		}
		out<<"\n";
	}
	return out;
}

template<class T>
void AdjMatrixGraph<T>::insertVertex(T vertex)
{
	vertexList.insert(vertex);
	vertCount++;
	if (vertCount>size)
	{
		int **temp=adjmatrix;
		adjmatrix=new int *[size*2];
		int i,j;
		for (i=0;i<size;i++)
		{
			adjmatrix[i]=new int[size*2];
			for (j=0;j<size;j++)
			{
				adjmatrix[i][j]=temp[i][j];
			}
			for (j=size;j<size*2;j++)
			{
				adjmatrix[i][j]=MAX_WEIGHT;
			}
		}
		for (i=size;i<size*2;i++)
		{
			adjmatrix[i]=new int[size*2];
			for (j=0;j<size*2;)
			{
				adjmatrix[i][j]=(i==j)?0:MAX_WEIGHT;
			}
		}
		size*=2;
	}
}

template<class T>
bool AdjMatrixGraph<T>::insertEdge(int i,int j,int weight)
{
	if (i>=0&&i<vertCount&&j>=0&&j<vertCount&&i!=j&&adjmatrix[i][j]==MAX_WEIGHT)
	{
		adjmatrix[i][j]=weight;
		return true;
	}
	return false;
}

template<class T>
bool AdjMatrixGraph<T>::insertEdge(Edge edge)
{
	return insertEdge(edge.start,edge.dest,edge.weight);
}

template<class T>
bool AdjMatrixGraph<T>::removeEdge(int i,int j)
{
	if (i>=0&&i<vertCount&&j>=0&&j<vertCount&&i!=j&&adjmatrix[i][j]!=MAX_WEIGHT)
	{
		adjmatrix[i][j]=MAX_WEIGHT;
		return true;
	}
	return false;
}

template<class T>
bool AdjMatrixGraph<T>::removeVertex(int v,T &old)
{
	if (v>=0&&v<vertCount&&vertexList.remove(v,old))
	{
		for (int i=v;i<vertCount-1;i++)
		{
			for (int j=0;j<vertCount;j++)
			{
				adjmatrix[i][j]=adjmatrix[i+1][j];
			}
		}

		for (int j=v;j<vertCount-1;j++)
		{
			for (int i=0;i<vertCount-1;i++)
			{
				adjmatrix[i][j]=adjmatrix[i][j+1];
			}
		}
		vertCount--;
		return true;
	}
	return false;
}

#include <iostream>
using namespace std;

template<class T>
class SeqList
{
public:
	SeqList(int size=64);
	SeqList(T value[],int n);
	~SeqList();

	bool isEmpty();
	int length();
	T get(int i);
	bool set(int i,T x);
	friend ostream &operator<<<T>(ostream &out,SeqList<T> &list);
	void insert(int i,T x);
	void insert(T x);
	bool remove(int i,T &old);
	void clear();

private:
	T *element;
	int size;
	int len;
};

template<class T>
SeqList<T>::SeqList(int size)
{
	this->size=size<64?64:size;
	this->element=new T[this->size];
	this->len=0;
}

template<class T>
SeqList<T>::SeqList(T value[],int n)
{
	if (n>0)
	{
		this->element=new T[2*n];
		this->size=2*n;
		this->len=n;

		for(int i=0;i <n;i ++)
		{
			this->element[i]=value[i];
		}
	}
}

template<class T>
SeqList<T>::~SeqList()
{
	delete []this->element;
}

template<class T>
bool SeqList<T>::isEmpty()
{
	return len==0;
}

template<class T>
int SeqList<T>::length()
{
	return len;
}

template<class T>
T SeqList<T>::get(int i)
{
	return element[i];
	/*if (i >=0&&i<len)
	{
	return element[i];
	}
	return "false";*/
}

template<class T>
bool SeqList<T>::set(int i,T x)
{
	if (i>=0&&i<len)
	{
		element[i]=x;
		return true;
	}
	return false;
}

template<class T>
ostream &operator<<(ostream &out,SeqList<T> &list)
{
	out<<"(";
	if (list.len>0)
	{
		out<<list.element[0];
		for (int i=1;i<list.len;i++)
		{
			out<<","<<list.element[i];
		}
	}
	out<<")\n";
	return out;
}

template<class T>
void SeqList<T>::insert(int i,T x)
{
	if (len==size)
	{
		T *temp=element;
		element=new T[size*2];
		for (int i=0;i<size;i ++)
		{
			element[i]=temp[i];
		}
		size*=2;
	}
	if (i<0)
	{
		i=0;
	}
	if (i>len)
	{
		i=len;
	}
	for (int j=len-1;j>=i;j--)
	{
		element[j+1]=element[j];
	}
	element[i]=x;
	len++;
}

template<class T>
void SeqList<T>::insert(T x)
{
	insert(len,x);
}

template<class T>
bool SeqList<T>::remove(int i,T &old)
{
	if (len>0&&i>=0&&i<len)
	{
		old=element[i];
		for (int j=i;j<len;j++)
		{
			element[j]=element[j+1];
		}
		len--;
		return true;
	}
	return false;
}

template<class T>
void SeqList<T>::clear()
{
	len=0;
}
#include "AdjMatrixGraph.h"
#include <iostream>
using namespace std;

int main()
{
	char *vertices="ABCDE";
	Edge edges[]={{0,1,5},{0,3,2},{1,0,5},{1,2,7},{1,3,6},{2,1,7},{2,3,8},{2,4,3},{3,0,2},{3,1,6},{3,2,8},{3,4,9},{4,2,3},{4,3,9}};
	AdjMatrixGraph<char> graph(vertices,5,edges,14);
	cout<<"带权无向图G3,\n"<<graph<<endl;
	graph.insertVertex('F');
	cout<<"插入顶点F,插入边(A,F,20)?"<<graph.insertEdge(0,5,20)<<"\n";
	char old=' ';
	if (graph.removeVertex(2,old))
	{
		cout<<"删除顶点"<<old<<"\n";
	}
	cout<<"删除边(v2,v3),"<<(graph.removeEdge(2,3)&&graph.removeEdge(3,2))<<"\n";
	cout<<graph<<endl;
	system("pause");
	return 0;
}


C++邻接矩阵实现有向图、无向图

/*********************邻接矩阵实现无向图******************/ class MatrixUDG { private: char mVexs[MAX];//...
  • weixin_38044916
  • weixin_38044916
  • 2017年05月03日 19:49
  • 786

C++邻接矩阵创建图及深度、广度遍历

#include "stdafx.h" #include #include using namespace std; #define VERTEX_MAX 26 //图的最大顶点数 #def...
  • pythontojava
  • pythontojava
  • 2015年10月27日 19:20
  • 3346

《数据结构》C++代码 邻接表与邻接矩阵

上一篇“BFS与DFS”写完,突然意识到这个可能偏离了“数据结构”的主题,所以回来介绍一下图的存储:邻接表和邻接矩阵。          存图有两种方式,邻接矩阵严格说就是一个bool型的二维数组,...
  • icedream61
  • icedream61
  • 2014年12月02日 10:14
  • 1367

图的邻接矩阵表示的C++类实现

任何的抽象数据类型(Abstract Data Type)都由3要素组成,名称、数据对象集合操作集。对于图的数据结构,其名称为Graph(图),数据对象集由一个非空的有限顶点集合和一个有限边集合组成,...
  • Alex123980
  • Alex123980
  • 2016年06月05日 15:41
  • 2635

图的邻接矩阵表示 DFS 和BFS C++实现

/* * File name : graph.cpp * Function : 图的学习, 邻接矩阵 深度优先遍历和广度优先遍历 C++实现 * Created on : 20...
  • beijiwei
  • beijiwei
  • 2016年05月27日 15:23
  • 507

C++ 图结构邻接矩阵简单实现

c++ 图结构邻接矩阵简单实现#ifndef GRAPHMAT_H #define GRAPHMAT_H#include using namespace std;#define MAX_VERTEX...
  • chenxl929
  • chenxl929
  • 2017年03月31日 21:04
  • 2189

c++邻接矩阵存储图

#include//对字符串的一系列操作 using namespace std;#define MAX_NAME 5 /* 顶点字符串的最大长度+1 */ #define MAX_INFO 20 /...
  • qq_38217873
  • qq_38217873
  • 2017年06月02日 20:54
  • 351

多源最短路径Floyd算法邻接矩阵形式C++实现

   多源最短路径Floyd算法邻接矩阵形式C++实现,输入点数、边数和起点、终点、权值,输出最短路径及权值#include #define MAX_VEX 305 #define MAX_WE...
  • yangliuy
  • yangliuy
  • 2010年11月24日 22:00
  • 5564

图的广度优先搜索遍历(邻接表&邻接矩阵)(C++)

图的广度优先搜索遍历这里只列了迭代的算法,递归比较困难搜索遍历需要借助一个队列。 每次将当前节点出队列,以及让该节点的所有未被访问的邻接节点入队列,重复直至队列为空。 节点的出队列的顺序构成了广度...
  • zhujiahui622
  • zhujiahui622
  • 2016年08月09日 15:24
  • 1184

图的存储结构——邻接矩阵(算法简介/c++实现)

邻接矩阵   用二维数组表示顶点间相邻关系的矩阵 无穷大的计算机存储:用宏MAX_VALUE(  计算机允许的、大于所有边上权值的数 )   邻接矩阵 const int ...
  • a244606999
  • a244606999
  • 2015年11月01日 16:56
  • 633
收藏助手
不良信息举报
您举报文章:邻接矩阵-C++
举报原因:
原因补充:

(最多只允许输入30个字)