邻接表-C++

原创 2015年11月19日 20:58:46
#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 "SinglyLinkedList.h"
#include <iostream>
using namespace std;

template<class T>
struct Vertex
{
	T data;
	SinglyLinkedList<Edge> adjlink;
};


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

template<class T>
class SinglyLinkedList
{
public:
	Node<T> *head;

	SinglyLinkedList();
	SinglyLinkedList(T value[],int n);
	~SinglyLinkedList();

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

private:

};

template<class T>
SinglyLinkedList<T>::SinglyLinkedList()
{
	this->head=NULL;
}

template<class T>
SinglyLinkedList<T>::SinglyLinkedList(T value[],int n)
{
	head=NULL;
	if (n>0)
	{
		head=new Node<T>(value[0]);
		Node<T> *rear=head;
		int i=1;
		while (i<n)
		{
			rear->next=new Node<T>(value[i++]);
			rear=rear->next;
		}
	}
}

template<class T>
SinglyLinkedList<T>::~SinglyLinkedList()
{
	clear();
}

template<class T>
bool SinglyLinkedList<T>::isEmpty()
{
	return head==NULL;
}

template<class T>
int SinglyLinkedList<T>::length()
{
	Node<T> *p=head;
	int i=0;
	while(p!=NULL)
	{
		i++;
		p=p->next;
	}
	return i;
}

template<class T>
Node<T> *SinglyLinkedList<T>::getNode(int i)
{
	if (i<0)
	{
		return NULL;
	}
	int j=0;
	Node<T> *p=head;
	while(p!=NULL&&j<i)
	{
		j++;
		p=p->next;
	}
	return p;
}

template<class T>
T SinglyLinkedList<T>::get(int i)
{
	Node<T> *p=getNode(i);
	if (p!=NULL)
	{
		return p->data;
	}
	throw "false";
}

template<class T>
bool SinglyLinkedList<T>::set(int i,T x)
{
	Node<T> *p=getNode(i);
	if (p!=NULL)
	{
		p->data=x;
		return true;
	}
	return false;
}

template<class T>
ostream &operator<<(ostream &out,SinglyLinkedList<T> &list)
{
	Node<T> *p=list.head;
	out<<"(";
	while (p!=NULL)
	{
		out<<p->data;
		p=p->next;
		if (p!=NULL)
		{
			out<<",";
		}
	}
	out<<")\n";
	return out;
}

template<class T>
Node<T> *SinglyLinkedList<T>::insert(int i,T x)
{
	Node<T> *q=NULL;
	if (head==NULL||i<=0)
	{
		q=new Node<T>(x,head);
		head =q;
	}
	else
	{
		int j=0;
		Node<T> *p=head;
		while (p->next!=NULL&&j<i-1)
		{
			j++;
			p=p->next;
		}
		q=new Node<T>(x,p->next);
		p->next=q;
	}
	return q;
}

template<class T>
bool SinglyLinkedList<T>::remove(int i,T &old)
{
	if (head!=NULL&&i>=0)
	{
		if (i==0)
		{
			Node<T> *q=head;
			old=q->data;
			head=head->next;
			delete q;
			return true;
		}
		else
		{
			Node<T> *p=getNode(i-1);
			if (p!=NULL&&p->next!=NULL)
			{
				Node<T> *q=p->next;
				old=q->data;
				p->next=q->next;
				delete q;
				return true;
			}
		}
	}
	return false;
}

template<class T>
void SinglyLinkedList<T>::clear()
{
	Node<T> *p=head;
	while (p!=NULL)
	{
		Node<T> *q=p;
		p=p->next;
		delete q;
	}
	head =NULL;
}

template<class T>
void SinglyLinkedList<T>::concat(SinglyLinkedList<T> &list)
{
	if (this->head==NULL)
	{
		this->head=list.head;
	}
	else
	{
		Node<T> *p=head;
		while (p->next!=NULL)
		{
			p=p->next;
		}
		p->next=list.head;
	}
	list.head=NULL;
}

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

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

	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,AdjListGraph<T> &graph);
	bool removeEdge(int i,int j);
	bool removeVertex(int v,T &old);

private:
	Vertex<T> *vertexList;
	int size;
	int vertCount;
};

template<class T>
AdjListGraph<T>::AdjListGraph(int size)
{
	this->size=size<10?10:size;
	this->vertexList=new Vertex<T>[this->size];
	this->vertCount=0;
}

template<class T>
AdjListGraph<T>::AdjListGraph(T vertices[],int vertCount,Edge edges[],int edgeCount)
{
	this->size=vertCount<10?10:vertCount;
	this->vertexList=new Vertex<T>[this->size];
	this->vertCount=0;

	for (int i=0;i<vertCount;i++)
	{
		insertVertex(vertices[i]);
	}
	for (int j=0;j<edgeCount;j++)
	{
		insertEdge(edges[j]);
	}
}

template<class T>
AdjListGraph<T>::~AdjListGraph()
{
	delete []vertexList;
}

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

template<class T>
T AdjListGraph<T>::get(int i)
{
	if (i=0&&i<vertCount)
	{
		return vertexList[i].data;
	}
	throw "false";
}

template<class T>
ostream &operator<<(ostream &out,AdjListGraph<T> &graph)
{
	for (int i=0;i<graph.vertCount;i++)
	{
		out<<" "<<"顶点"<<graph.vertexList[i].data<<" 出边表:";
		out<<graph.vertexList[i].adjlink;
	}
	return out;
}

template<class T>
void AdjListGraph<T>::insertVertex(T vertex)
{
	if (vertCount==size)
	{
		Vertex<T> *temp=vertexList;
		vertexList=new Vertex<T>[size*2];
		for (int i=0;i<size;i++)
		{
			vertexList[i]=temp[i];
		}
		size*=2;
	}
	vertexList[vertCount].data=vertex;
	vertCount++;
}

template<class T>
bool AdjListGraph<T>::insertEdge(int i,int j,int weight)
{
	if (i>=0&&i<vertCount&&j>=0&&j<vertCount&&i!=j)
	{
		Edge e={i,j,weight};
		Node<Edge> *p=vertexList[i].adjlink.head,*front;
		if (p==NULL||p!=NULL&&j<p->data.dest)
		{
			vertexList[i].adjlink.head=new Node<Edge>(e,p);
			return true;
		}
		while (p!=NULL)
		{
			if (j==p->data.dest)
			{
				return false;
			}
			front=p;
			p=p->next;
		}
		front->next=new Node<Edge>(e,p);
		return true;
	}
	return false;
}

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

template<class T>
bool AdjListGraph<T>::removeEdge(int i,int j)
{
	if (i>=0&&i<vertCount&&j>=0&&j<vertCount&&i!=j)
	{
		Node<Edge> *p=vertexList[i].adjlink.head,*front;
		if (p!=NULL&&p->data.dest==j)
		{
			vertexList[i].adjlink.head=p->next;
			delete p;
			return true;
		}
		while(p!=NULL&&p->data.dest!=j)
		{
			front=p;
			p=p->next;
		}
		if (p!=NULL)
		{
			front->next=p->next;
			delete p;
			return true;
		}
	}
	return false;
}

template<class T>
bool AdjListGraph<T>::removeVertex(int v,T &old)
{
	if (v<0||v>=vertCount)
	{
		return false;
	}
	Node<Edge> *p=vertexList[v].adjlink.head;
	while (p!=NULL)
	{
		removeEdge(p->data.dest,p->data.start);
		p=p->next;
	}
	old=vertexList[v].data;
	vertexList[v].adjlink.clear();

	int i;
	for (i=v;i<vertCount-1;i++)
	{
		vertexList[i].data=vertexList[i+1].data;
		vertexList[i].adjlink.head=vertexList[i+1].adjlink.head;
		vertexList[i+1].adjlink.head=NULL;
	}
	vertCount--;

	for(i=0;i<vertCount;i++)
	{
		p=vertexList[i].adjlink.head;
		while (p!=NULL)
		{
			if (p->data.start>v)
			{
				p->data.start--;
			}
			if (p->data.dest>v)
			{
				p->data.dest--;
			}
			p=p->next;
		}
	}
	return true;
}

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

int main()
{
	char *vertices="ABCDE";
	Edge edges[]={{0,1,5},{0,3,2},{1,0,6},{1,2,7},{2,4,3},{3,2,8},{3,4,9}};
	AdjListGraph<char> graph(vertices,5,edges,7);
	cout<<"带权有向图G4,\n"<<graph<<endl;

	char old=' ';
	if (graph.removeVertex(2,old))
	{
		cout<<"删除顶点"<<old<<",";
	}
	cout<<"删除边(V2,V3),"<<graph.removeEdge(2,3)<<"\n";
	cout<<graph<<endl;
	system("pause");
	return 0;
}


数据结构:图(邻接表存储 c++实现)

#include #include #include using namespace std; #define MAXVEX 10 #define INFINITY 0XFFFFFFFF #d...
  • s634772208
  • s634772208
  • 2015年05月08日 15:12
  • 8529

<C/C++图>图的邻接表存储(C++模板实现)

一,邻接表表示法 图的邻接矩阵存储方法跟树的孩子链表示法相类似,是一种顺序分配和链式分配相结合的存储结构。邻接表由表头结点和表结点两部分组成,其中图中每个顶点均对应一个存储在数组中的表头结点。如这个...
  • EbowTang
  • EbowTang
  • 2015年03月09日 23:13
  • 5607

C++ 图结构邻接表简单实现

参照严蔚敏老师的《数据结构》一书,第7章实现 图结构的邻接表实现方式 表节点: 邻接点域(adjvex),链域(nextarc),数据域(info)。 头结点: 顶点信息(data),链域(...
  • chenxl929
  • chenxl929
  • 2017年04月15日 12:09
  • 1538

图的邻接表c++表示

  • 2009年08月12日 09:55
  • 2KB
  • 下载

c++ 有向图

// // main.cpp // CmdPointTree // // Created by weixian he on 12-2-3. // Copyright (c) 2012年 __M...
  • switchcore
  • switchcore
  • 2012年02月03日 12:55
  • 2690

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

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

有向图的邻接表描述 c++

有向图的邻接表表示法 图的邻接表表示法类似于树的孩子链表表示法。对于图G中的每个顶点vi,该方法把所有邻接于vi的顶点vj链成一个带头结点的单链表,这个单链表就称为顶点vi的邻接表(...
  • u014805066
  • u014805066
  • 2016年01月08日 16:26
  • 473

图的邻接表数据结构的C++实现方法

图的邻接表表示方法采用链表的方式针对每个节点创建一个属于自己的链表,其中头指针为节点自身,其后的所有元素为与自己相连的其他节点,头结点只需记录节点的名字和序号,链表的其他节点还需记录两点之间边的权值,...
  • Alex123980
  • Alex123980
  • 2016年06月06日 14:44
  • 2124

C++实现图算法(一)

图算法(一) 对图的顶点和边进行了封装。
  • aiversonwk
  • aiversonwk
  • 2011年03月21日 16:24
  • 8385

UVA - 1601 The Morning after Halloween (bfs 单向/双向)

题目网址点击打开链接 给出一个最大为16×16的迷宫图和至多3个ghost的起始位置和目标位置,求最少经过几轮移动可以使三个ghost都到达目标位置。每轮移动中,每个ghost可以走一步,也可以原地...
  • sinat_36215255
  • sinat_36215255
  • 2017年08月09日 18:43
  • 57
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:邻接表-C++
举报原因:
原因补充:

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