图的C++关键路径代码

 

#include <iostream>
using namespace std;
//*****stack.h以下是栈的实现
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
template<class QElemType>
class stack
{
public:
 void InitStack();
 void DestroyStack();
 void ClearStack();
 Status StackEmpty();
 Status StackLength();
 void GetTop(QElemType & e);
 void Push(QElemType e);
 void Pop(QElemType & e);
private:
 struct SqStack{
  QElemType *base;
  QElemType *top;
  int stacksize;
 }S;
};
//******stack.cpp------
template<class QElemType>
void stack<QElemType>::InitStack()
{
 S.base = (QElemType *)malloc(STACK_INIT_SIZE * sizeof(QElemType));
 if(!S.base) exit(0);
 S.top = S.base;
 S.stacksize = STACK_INIT_SIZE;
}
template <class QElemType>
void stack<QElemType>::DestroyStack()
{
 free(S.base);
}
template <class QElemType>
void stack<QElemType>::ClearStack()
{
 S.top = S.base;
}
template <class QElemType>
Status stack<QElemType>::StackEmpty()
{
 if(S.top == S.base) return 1;
 else return 0;
}
template <class QElemType>
Status stack<QElemType>::StackLength()
{
 return (S.top - S.base);
}
template <class QElemType>
void stack<QElemType>::GetTop(QElemType & e)
{
 if(S.top != S.base)
  e = *(S.top - 1);
 else cout << "ERROR" << endl;
}
template <class QElemType>
void stack<QElemType>::Push(QElemType e)
{
 if(S.top - S.base >= S.stacksize)
 {
  S.base = (QElemType *)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(QElemType));
  if(!S.base) exit(0);
  S.top = S.base + S.stacksize;
  S.stacksize += STACKINCREMENT;
 }
 *S.top++ = e;
}
template <class QElemType>
void stack<QElemType>::Pop(QElemType & e)
{
 if(S.top == S.base) cout << "ERROR" << endl;
 else
  e = * --S.top;
}
//********* ****栈实现结束

 

 

//********图的实现
//*********Graph.h图的实现

template <class TElemType>
class Graph
{
 public:
  void CreateAlgraph();
  void DestroyAlgraph();
  void TopologicalSort();                              //有向图拓扑排序，检验环的存在与否
  float * TopologicalOrder(stack<int> &sre,int &e);
  void Criticalpath();            //求有向无环图关键路径
 private:
  int count;

  struct Arcnode       
  {
   int adjvex;
   Arcnode *nextarc;
   float weight;
  };
  template <class TElemType>
  struct Vexnode
  {
   TElemType data;
   Arcnode *firarc;
  };
  struct ALgraph
  {
   int vexnum;
   int arcnum;
   bool kind;
   Vexnode<TElemType> *vex;
  };
  ALgraph algraph;           //邻接表存储
};

template <class TElemType>
void Graph<TElemType>::CreateAlgraph()
{
 int i,j,m,n;
 float w;
 TElemType v1,v2;
 Arcnode *p;
 cout << "输入图类型（1是无向图，0是有向图):" << endl;
 cin >> algraph.kind;
 cout << "输入顶点数和边数:" << endl;
 cin >> algraph.vexnum >> algraph.arcnum;
 algraph.vex = (Vexnode<TElemType> *)malloc(algraph.vexnum * sizeof(Vexnode<TElemType>));
 cout << "输入顶点信息:" << endl;
 for(i = 0;i < algraph.vexnum;i++)
 {
  cin >> algraph.vex[i].data;
  algraph.vex[i].firarc = NULL;
 }

 if(algraph.kind)
 {
  cout << "输入各边依附的两点和权值:" << endl;
  for(i = 0;i < algraph.arcnum;i++)
  {
   cin >> v1 >> v2 >>w;
   for(j = 0;j < algraph.vexnum;j++)
   {
    if(v1 == algraph.vex[j].data) m = j;
    if(v2 == algraph.vex[j].data) n = j;
   }
   p = (Arcnode *)malloc(2*sizeof(Arcnode));
   p[0].adjvex = n;p[0].weight = w;
   p[1].adjvex = m;p[1].weight = w;
   p[0].nextarc = algraph.vex[m].firarc;algraph.vex[m].firarc = p;
   p[1].nextarc = algraph.vex[n].firarc;algraph.vex[n].firarc = ++p;
  }
 }

 else
 {
  cout << "输入各边的弧尾与弧头结点及有向边的权值:" << endl;
  for(i = 0;i < algraph.arcnum;i++)
  {
   cin >> v1 >> v2 >> w;
   for(j = 0;j < algraph.vexnum;j++)
   {
    if(v1 == algraph.vex[j].data) m = j;
    if(v2 == algraph.vex[j].data) n = j;
   }
   p = (Arcnode *)malloc(sizeof(Arcnode));
   p->adjvex = n;p->weight = w;
   p->nextarc = algraph.vex[m].firarc;algraph.vex[m].firarc = p;
  }
 }
}                 //构造完成

template <class TElemType>
void Graph<TElemType>::DestroyAlgraph()
{
 int i;
 Arcnode *p,*q;
 for(i = 0;i < algraph.vexnum;i++)
 {
  p = algraph.vex[i].firarc;
  if(p)
  {
   q = p->nextarc;
  while(q)
  {
   free(p);
   p = q;
   q = q->nextarc;
  }
  free(p);
  }
 }
 free(algraph.vex);
}

template <class TElemType>
float * Graph<TElemType>::TopologicalOrder(stack<int> &sre,int &e)
{
 stack<int> topo;
 topo.InitStack();
 sre.InitStack();
 float *re = (float *)malloc(algraph.vexnum * sizeof(float));
 int *indegree = (int *)malloc(algraph.vexnum * sizeof(int));
 int i,v,v1,count = 0;
 for(i = 0;i < algraph.vexnum;i++) re[i] = 0;

 Arcnode *p;
 for(i = 0;i < algraph.vexnum;i++) indegree[i] = 0;
 for(i = 0;i < algraph.vexnum;i++)
  for(p = algraph.vex[i].firarc;p;p = p->nextarc)
  {
   v = p->adjvex;
   indegree[v]++;
  }
  for(i = 0;i < algraph.vexnum;i++)
   if(indegree[i] == 0) topo.Push(i);
   while(!topo.StackEmpty())
   {
    topo.Pop(v);
    sre.Push(v);
    count++;
    for(p = algraph.vex[v].firarc;p;p = p->nextarc)
    {
     v1 = p->adjvex;
     if(0 == --indegree[v1]) topo.Push(v1);
     if(re[v] + p->weight > re[v1]) re[v1] = re[v] + p->weight;
    }
   }
   e = v;
   topo.DestroyStack();
   if(count < algraph.vexnum) return NULL;
   return re;
}

template <class TElemType>
void Graph<TElemType>::Criticalpath()
{
 float *rl = (float *)malloc(algraph.vexnum * sizeof(float));
 stack<int> sre;
 int e;
 float *re = TopologicalOrder(sre,e);
 if(re)
 {
 int i,v,v1;
 Arcnode *p;
 for(i = 0;i < algraph.vexnum;i++) rl[i] = re[e];
 while(!sre.StackEmpty())
 {
  sre.Pop(v);
  for(p = algraph.vex[v].firarc;p;p = p->nextarc)
  {
   v1 = p->adjvex;
   if(rl[v1] - p->weight < rl[v]) rl[v] = rl[v1] - p->weight;
  }
 }
    cout << "关键路径如下:" << endl;
 for(i = 0;i < algraph.vexnum;i++)
  for(p = algraph.vex[i].firarc;p;p = p->nextarc)
  {
   v1 = p->adjvex;
   if(rl[v1]-p->weight == re[i]) cout << "(" << algraph.vex[i].data << "," << algraph.vex[v1].data << ") ";
  }
  cout << endl;
  free(re);
 }
 else cout << "有向图中存在环,不合要求!" << endl;
  free(rl);
  sre.DestroyStack();
}

//小测试程序test.cpp

int main()
{
 Graph<int> gph;
 gph.CreateAlgraph();
 gph.Criticalpath();
 gph.DestroyAlgraph();
 return 0;
}