数据结构-最小生成树的实现

// mygraph2.cpp : Defines the entry point for the console application.

//

/*

题目:用邻接表的形式表示图。最小生成树

编译器:visualc++ 6.0

参考资料:《数据结构（用面向对象方法与c++语言描述）》

尚未处理的边放在最小堆中，通过并査集的find运算，可以很快的判断任意一条边的两个端点是否来自同一个联通分量，

是就舍去，不是就留下，通过并査集的union运算，将两棵树合二为一，直到成了一棵树

P262-266并査集实现

P235-239最小堆的实现

P349-P350 图的模板基类

P355-P356 用邻接表表示图

P364-P366 图的广度优先和深度优先搜索

P372 krusakal算法实现最小生成树

*/

#include "StdAfx.h"

#include

#include

#include

using namespace std;

#define DefaultVertices 30

//图的基类，主要包含初始化，虚函数，方便以后拓展

template

class Graph{

public:

Graph(intsz=DefaultVertices){} //constructor

~Graph(){} // destructor

boolGraphEmpty(){ // isempty

if(numEdges==0)

return true;

else

return false;

}

boolGraphFull(){ //isfull

if(numVertices==maxVertices||numEdges==maxVertices*(Vertices-1)/2)

return true;

else

return false;

}

intNumberOfVertices() // return the number of current vertices

{

returnnumVertices;

}

intNumberOfEdges() //return the number of current edges {

returnnumEdges;

}

virtual T getValue(inti)=0;

virtual E getWeight(int v1,int v2)=0;

virtualintgetFirstNeighbor(int v)=0;

virtualintgetNextNeighbor(intv,int w)=0;

virtualboolinsertVertex(T& vertex)=0;

virtualboolinsertEdge(int v1,int v2,E cost)=0;

virtualboolremoveVertex(int v)=0;

virtualboolremoveEdge(int v1,int v2)=0;

intmaxVertices;

intnumEdges;

intnumVertices;

virtualintgetVertexPos(T vertex)=0;

};

//边的结构体

template

struct Edge{

intdest; //存放的是指向那个

E cost; //权值

Edge *link;

Edge(){} //构造函数

Edge(intnum,E weight):dest(num),cost(weight),link(NULL){}

bool operator !=(Edge& R){

return (dest!=R.dest)?true:false;

}

};

//顶点的结构体,包含数据，还有边

template

struct Vertex{

T data;

Edge *adj;

};

//用邻接矩阵表示的图的形式

template

classGraphlnk:public Graph{

friendistream& operator>>(istream&in,Graphlnk& G);

friendostream& operator<<(ostream&out,Graphlnk& G); public:

Graphlnk(intsz=DefaultVertices); //构造函数

~Graphlnk(); //析构函数

T getValue(inti) //获得处于i位置的值{

return (i>=0&&i

}

E getWeight(int v1,int v2); //获得权值

boolinsertVertex(T& vertex); //插入顶点

boolremoveVertex(int v); //移除顶点

boolinsertEdge(int v1,int v2,E cost); //插入边

boolremoveEdge(int v1,int v2); //移除边

intgetFirstNeighbor(int v);//获得第一个

intgetNextNeighbor(intv,int w);//获得相邻的

Vertex *NodeTable;

intgetVertexPos(T vertex)

{

for(inti=0;i

if(NodeTable[i].data==vertex)

returni;

return -1;

}

};

/**///建立空图

template

Graphlnk::Graphlnk(intsz)

{

//this

maxVertices=sz;

numVertices=0;

numEdges=0;

//创建顶点数组

NodeTable=new Vertex[maxVertices];

if(NodeTable==NULL)

cout<<"存储失败"<

for(inti=0;i

NodeTable[i].adj=NULL;

};

//destructor /

template

Graphlnk::~Graphlnk()

{

for(inti=0;i

{

Edge *p=NodeTable[i].adj;

while(p!=NULL)

{

NodeTable[i].adj=p->link;

delete p;

p=NodeTable[i].adj;

}

}

delete[] NodeTable;

}

//获取边的权值

template

E Graphlnk::getWeight(int v1,int v2) {

if(v1!=-1&&v2!=-1)

{

Edge *p=NodeTable[v1].adj;

while(p!=NULL&&p->dest!=v2){

p=p->link;

}

if(p!=NULL)

return p->cost;

}

return 0;

}

//插入顶点的函数实现

template

boolGraphlnk::insertVertex(T& vertex) {

if(numVertices==maxVertices)

return false;

NodeTable[numVertices].data=vertex;

numVertices++;

return true;

};

//删除顶点的实现

template

boolGraphlnk::removeVertex(int v)

{

if(numVertices==1||v<0||v>=numVertices)

return false;

Edge*p,*s,*t;

int k;

//删除第v个边链表的顶点

while(NodeTable[v].adj!=NULL)

{

cout<<"测试顶点的数值"<

//cout<<"test"<

p=NodeTable[v].adj;

cout<<"p的权值"<cost<

k=p->dest;

cout<<"k是邻接节点"<

//找对称存放的边结点

s=NodeTable[k].adj;

cout<<"s->cost 测试"<cost<

t=NULL;

while(s!=NULL&&s->dest!=v)

{

//cout<

t=s;

s=s->link;

cout<<"s->dest"<dest<

cout<link<<"能显示吗"<

cout<<"在while循环测"<cost<

}

//删除堆存放的边结点

cout<<"删除堆存放的边结点"<

if(s!=NULL)

{

if(t==NULL){

cout<<"s->link的权值"<link->cost<

NodeTable[k].adj=s->link;

cout<<"NodeTable[k].adjifceshi"<cost<

}

else{

cout<link->cost<<"之前"<

cout<link<

t->link=s->link;

//cout<link->cost<<"之后"<

}

delete s;

}

//清除顶点v的边链表结点

NodeTable[v].adj=p->link;

delete p;

numEdges--;

}

// cout<<"执行出来"<

numVertices--;

//填补

cout<<"NodeTable[v].data"<

NodeTable[v].data=NodeTable[numVertices].data;

p=NodeTable[v].adj=NodeTable[numVertices].adj;

cout<<"p=NodeTable[v].adj=NodeTable[numVertices].adj "<cost<

while(p!=NULL)

{

// cout<<"死循环？？"<

// cout<dest].data<

s=NodeTable[p->dest].adj;

while(s!=NULL)

if(s->dest==numVertices)

{

s->dest=v;

break;

}

else

s=s->link;

p=p->link;

}

return true;

};

//移除边的函数的实现

template

boolGraphlnk::removeEdge(int v1,int v2)

{

if(v1!=-1&&v2!=-1)

{

Edge *p=NodeTable[v1].adj,*q=NULL,*s=p;

while(p!=NULL&&p->dest!=v2)

{

q=p;

p=p->link;

}

if(p!=NULL)

{

if(p==s)

NodeTable[v1].adj=p->link;

else

q->link=p->link;

delete p;

}

else

return false;

p=NodeTable[v2].adj;

q=NULL,s=p;

while(p->dest!=v1)

{

q=p;

p=p->link;

}

if(p==s)

NodeTable[v2].adj=p->link;

else

q->link=p->link;

delete p;

return true;

}

return false;

};

//插入边的函数实现

template

boolGraphlnk::insertEdge(int v1,int v2,E weight)

{

if(v1>=0&&v1=0&&v2

//v1对应边链表头指针

Edge *q,*p=NodeTable[v1].adj;

//寻找邻接顶点v2

while(p!=NULL&&p->dest!=v2)

p=p->link;

//找到此边不插入

if(p!=NULL)

return false;

// 否则，创建新结点

p=new Edge;

q=new Edge;

p->dest=v2;

p->cost=weight;

p->link=NodeTable[v1].adj;

//链入v1边链表

NodeTable[v1].adj=p;

q->dest=v1;

q->cost=weight;

q->link=NodeTable[v2].adj;

//链入v2边链表

NodeTable[v2].adj=q;

numEdges++;

return true;

}

return 0;

};

//获得第一个邻接定点的位置

template

intGraphlnk::getFirstNeighbor(int v)

{

//对应边链表第一个边节点

if(v!=-1)

{

//存在，返回第一个邻接顶点

Edge *p=NodeTable[v].adj;

if(p!=NULL)

//第一个邻接顶点不存在

return p->dest;

}

return -1;

};

//输出某邻接顶点w的下一邻接顶点，思路同上template

intGraphlnk::getNextNeighbor(intv,int w) {

if(v!=-1)

{

Edge *p=NodeTable[v].adj;

while(p!=NULL&&p->dest!=w)

p=p->link;

if(p!=NULL&&p->link!=NULL)

return p->link->dest;

}

return -1;

};

//重载运算符

template

istream& operator>>(istream&in,Graphlnk& G){ int choose;

cout<<"what do you want to do"<

in>>choose;

switch(choose)

{

case 0: break;

}

}

//重载运算

template

ostream& operator<<(ostream&out,Graphlnk& G) {

for(inti=0;i

out<

return out;

}

//深度优先搜索

template

void DFS(Graph& G,T& v)

{

inti,n=G.NumberOfVertices();

intloc;

bool *visited=new bool[n];

for(i=0;i

visited[i]=false;

loc=G.getVertexPos(v);

DFS(G,loc,visited);

delete[] visited;

}

//深度优先具体实现

template

void DFS(Graph&G,intv,bool visited[])

{

//深度优先，

cout<

visited[v]=true;

int w=G.getFirstNeighbor(v);

while(w!=-1)

{

if(visited[w]==false)

DFS(G,w,visited);

w=G.getNextNeighbor(v,w);

}

}

//广度优先=函数

template

void BFS(Graph& G,T& v)

{

inti,w,n=G.NumberOfVertices();

bool *visited=new bool[n];

for(i=0;i

visited[i]=false;

intloc=G.getVertexPos(v);

cout<

visited[loc]=true;

queue q;

q.push(loc);

while(!q.empty())

{

intloc=q.front();

q.pop();

w=G.getFirstNeighbor(loc);

while(w!=-1)

{

if(visited[w]==false)

{

cout<

visited[w]=true;

q.push(w);

}

w=G.getNextNeighbor(loc,w);

}

}

delete[] visited;

}

//并査集

intDefaultSize=10;

classUFSets{

public:

UFSets(intsz=DefaultSize);

~UFSets(){delete[] parent;}

UFSets& operator=(UFSets& R);

void Union(int Root1,int Root2);

int Find(int x);

voidWeightUnion(int Root1,int Root2);

int *parent;

int size;

};

//并査集构造函数

UFSets::UFSets(intsz)

{

size=sz;

parent=new int[size];

for(inti=0;i

parent[i]=-1;

}

//并査集查找

intUFSets::Find(int x)

{

while(parent[x]>=0)

x=parent[x];

return x;

}

//union简单，但是好容易出现退化树的情况

voidUFSets::Union(int Root1,int Root2)

{

parent[Root1]+=parent[Root2];

parent[Root2]=Root1;

}

//P265，为了避免出现退化的树，而用的算法，用加权的原则来改进union算法voidUFSets::WeightUnion(int Root1,int Root2)

{

int r1=Find(Root1),r2=Find(Root2),temp;

if(r1!=r2)

{

temp=parent[r1]+parent[r2];

if(parent[r1]>parent[r2])

{

parent[r1]=r2;

parent[r2]=temp;

}

else

{

parent[r2]=r1;

parent[r1]=temp;

}

}

else

Union(Root1,Root2);

}

//最小生成树边节点的类声明

template structMSTEdgeNode{

//顶点的位置以及权值

inttail,head;

E key;

//构造函数

MSTEdgeNode():tail(-1),head(-1),key(0){}

bool operator<=(MSTEdgeNode& R)

{

return key<=R.key;

}

bool operator>(MSTEdgeNode& R)

{

return key>R.key;

}

};

//最小生成树

template classMinSpanTree{

protected:

MSTEdgeNode *edgevalue;

intmaxSize,n;

public:

MinSpanTree(intsz=DefaultSize-1):maxSize(sz),n(0)

{

edgevalue=new MSTEdgeNode[sz];

}

int Insert(MSTEdgeNode& item);

};

//最小生成树的插入

template

intMinSpanTree::Insert(MSTEdgeNode& item)

{

cout<

return 0;

}

//P124~P125优先队列

constintDefaultPQSize=50;

template

classPQueue{

public:

PQueue(intsz=DefaultPQSize); //构造函数

~PQueue(){delete[] pqelements;} //析构函数

bool Insert(T& x); //插入函数

boolRemoveMin(T& x); //移除最小元素

boolgetFront(T& x); //取出最小元素

void makeEmpty(){count=0;} //制空队列

boolIsEmpty() //判断是队列否为空{return (count==0)?true:false;}

boolIsFull() //判断队列是否已满{return (count==maxSize)?true:false;}

intgetSize() //获得队列目前大小{return count;}

protected:

T *pqelements; //data

int count; //当前队列个数

intmaxSize; //队列最大值

void adjust(); //调整函数

};

//最小优先级最烈的构造函数P125

template

PQueue::PQueue(intsz):maxSize(sz),count(0)

{

pqelements=new T[maxSize];

assert(pqelements!=NULL);

}

//插入函数，插入到队尾P125

template

boolPQueue::Insert(T& x)

{

if(count==maxSize)

return false;

pqelements[count++]=x;

adjust();

return true;

}

//删除优先权值最小元素P126

template

boolPQueue::RemoveMin(T& x)

{

if(count==0)

return false;

x=pqelements[0];

for(inti=1;i

pqelements[i-1]=pqelements[i];

count--;

return true;

}

//取得最小优先权函数的值P126

template

boolPQueue::getFront(T& x)

{

if(count==0)

return false;

else

{

x=pqelements[0];

return true;

}

}

//P125~P126 将队尾元素按优先权调整到适当的位置，保持优先权不变template

voidPQueue::adjust()

{

T temp=pqelements[count-1];

int j;

for(j=count-2;j>=0;j--)

if(pqelements[j]<=temp)

break;

else

pqelements[j+1]=pqelements[j];

pqelements[j+1]=temp;

}

//P236 最小堆的类

template

classMinHeap:publicPQueue{

public:

MinHeap(intsz=DefaultSize); //构造函数

MinHeap(E arr[],int n); //重载构造函数

~MinHeap(){delete[] heap;} //析构函数

bool Insert(E& x); //插入函数

boolRemoveMin(E& x); //移除最小值函数

boolIsEmpty() //查看是否是空

{return (currentSize==0)?true:false;}

boolIsFull() //查看是否是满的

{return (currentSize==maxHeapSize)?true:false;}

void MakeEmpty() //将最小堆置成空

{currentSize=0;}

E getMin(); // 获取最小值

void output(); //输出最小堆的元素，进行验证private:

E* heap; //存放最小堆元素的数组

intcurrentSize; //最小堆当前元素的个数

intmaxHeapSize; //最小堆最多元素个数

void siftDown(intstart,int m); //下滑调整为最小堆

void siftUp(int start); //上滑调整为最小堆

};

//构造函数P237

template

MinHeap::MinHeap(intsz)

{

maxHeapSize=(DefaultSize

heap=new E[maxHeapSize];

if(heap==NULL)

{cerr<<"123"<

currentSize=0;

}

//最小堆的构造函数P237

template

MinHeap::MinHeap(E arr[],int n)

{

maxHeapSize=(DefaultSize

heap=new E[maxHeapSize];

if(heap==NULL)

{cerr<<"123"<

for(inti=0;i

heap[i]=arr[i];

currentSize=n;

intcurrentPos=(currentSize-2)/2;

while(currentPos>=0)

{

siftDown(currentPos,currentSize-1);

currentPos--;

}

}

//最小堆的下滑调整P238

template

voidMinHeap::siftDown(intstart,int m)

{

inti=start,j=2*i+1;

E temp=heap[i];

while(j<=m)

{

if(jheap[j+1])

j++;

if(temp<=heap[j])

break;

else

{

heap[i]=heap[j];

i=j;

j=2*j+1;

}

}

heap[i]=temp;

}

//最小堆的上滑调整P238~P239

template

voidMinHeap::siftUp(int start) {

int j=start,i=(j-1)/2;

E temp=heap[j];

while(j>0)

{

if(heap[i]<=temp)

break;

else

{

heap[j]=heap[i];

j=i;

i=(i-1)/2;

}

}

heap[j]=temp;

}

//最小堆移除最小值也就是根P239 template

boolMinHeap::RemoveMin(E& x) {

if(!currentSize)

{

cout<<"Heap Empty"<

return false;

}

x=heap[0];

heap[0]=heap[currentSize-1];

currentSize--;

siftDown(0,currentSize-1);

return true;

}

//最小堆的插入P239

template

boolMinHeap::Insert(E& x)

{

if(currentSize==maxHeapSize)

{

cerr<<"Heap Full"<

return false;

}

heap[currentSize]=x;

siftUp(currentSize);

currentSize++;

return true;

}

//获得最小堆的根

template

E MinHeap::getMin()

{

return heap[0];

}

//最小堆的输出

template

voidMinHeap::output()

{

for(inti=0;i

cout<

cout<

}

//krusal算法，逐步寻找最小权值的边，然后连接

template

voidKruskal(Graph&G,MinSpanTree& MST)

{

MSTEdgeNodeed;

intu,v,count;

//n是顶点的数目

int n=G.NumberOfVertices();

//m是边的数目

int m=G.NumberOfEdges();

MinHeap> H(m);

UFSets F(n);//并査集

for(u=0;u

for(v=u+1;v

if(G.getWeight(u,v)!=0)

{

// cout<<"u"<

// cout<

ed.tail=u;

ed.head=v;

ed.key=G.getWeight(u,v);

H.Insert(ed);

}

count=1;

//最小生成树加入边数计算

cout<<"这是分割线"<

while(count

{

//反复执行，取N-1条边

H.RemoveMin(ed);

//从最小对中退出具有最小值的边ed

u=F.Find(ed.tail);

v=F.Find(ed.head);

// cout<<"u"<

//取两定点所在党的根U,V

if(u!=v)

{

cout<<"u"<

//合并，联通他们

F.Union(u,v);

MST.Insert(ed);

count++;

}

}

}

//----------------------------------主函数----------------------

//大多数测试都在step6中完成的，这一步主要完成最小生成树int main()

{

MinSpanTreemst;

Graphlnk graph(7);

int a[7]={0,1,2,3,4,5,6};

for(inti=0;i<7;i++)

graph.insertVertex(a[i]);

//前面构建书上树已经成功，现在构建自己的树

graph.insertEdge(0,1,100);

graph.insertEdge(1,3,110);

graph.insertEdge(3,4,60);

graph.insertEdge(4,6,70);

graph.insertEdge(5,6,80);

graph.insertEdge(2,0,10);

graph.insertEdge(2,5,30);

graph.insertEdge(2,3,20);

graph.insertEdge(2,4,50);

graph.insertEdge(2,6,40);

graph.insertEdge(5,0,90);

//广度优先搜索

cout<<"这是广度优先"<

BFS(graph,a[0]);

cout<

//深度优先搜索，depth,是往下一直找

cout<<"这是深度优先"<

DFS(graph,a[0]);

cout<

//MSTEdgeNode

//根据书上的图所做的，kruskal算法

Kruskal(graph,mst);

cout<<"节点的数目"<

cout<<"边的数目"<

// if (graph.removeVertex(6))

// cout<<"删除成功"<

/* if (graph.removeVertex(3))

{

cout<<"删除成功"<

}

*/

if (graph.removeVertex(1))

cout<<"删除成功"<

cout<<"节点的数目"<

cout<<"边的数目"<

//cout<

return 0;

}