十字链表 邻接表实现各种操作

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

#include "stdafx.h"
#include <stdlib.h>
/************************************************************************/
/*                  图的种类                                            */
/************************************************************************/
typedef enum {
 DG,DN,UDG,UDN //{有向图，有向网，无向图，无向网}
}GraphKind;
/************************************************************************/
/*                         全局变量                                     */
/************************************************************************/
 //最多顶点数
#define INFINITY   INT_MAX      //最大值（无穷大）
#define MAX_VERTEX_NUM   30
typedef char VertexType;
typedef char InfoType;

/************************************************************************/
/*                     邻接矩阵                                         */
/************************************************************************/
typedef struct ArcCell { // 弧的定义
 int  adj;    // VRType是顶点关系类型。
    // 对无权图，用1或0表示相邻否；
    // 对带权图，则为权值类型。
 InfoType  *info;  // 该弧相关信息的指针
} ArcCell;

typedef struct { // 图的定义
 VertexType vexs[MAX_VERTEX_NUM]; // 顶点信息
 ArcCell   arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
                                                                           // 弧的信息                 
 int    vexnum, arcnum;   // 顶点数，弧数     
 GraphKind   kind;     // 图的种类标志            
} MGraph;
/************************************************************************/
/*                                   邻接表                             */
/************************************************************************/
typedef struct ArcNode {
 int adjvex;//该弧所指向的顶点的位置
 struct ArcNode *nextarc;//指向下一条弧的指针
 int weight;
 InfoType *info;// 该弧相关信息指针
}ArcNode;

typedef struct VNode {
 VertexType data;//该顶点的信息
 ArcNode *firstarc;//指向第一条依附该顶点的弧的指针
}VNode,AdjList[MAX_VERTEX_NUM];

typedef struct {
 AdjList vertices;
 int vexnum,arcnum;//图当前定点数和弧数
 int kind; //图的种类标志
}ALGraph;

/************************************************************************/
/*                                 十字链表                             */
/************************************************************************/
typedef struct ArcBox {                           // 弧的结构表示
 int tailvex, headvex;              // 该弧的尾和头顶点的位置
 InfoType  *info;            // 该弧的相关信息
 struct ArcBox  *hlink, *tlink;            // 弧头相同和弧尾相同的弧的链域
 int weight;
}ArcBox;

typedef struct VexNode {                          // 顶点的结构表示
 VertexType data; 
 ArcBox  *firstin,*firstout; //分别指向该顶点第一条入弧和出弧 ;
 int use;   
}VexNode;

typedef struct{
 VexNode xlist[MAX_VERTEX_NUM];
 int vexnum,arcnum;
 int length;
}OLGraph;
/************************************************************************/
/*                        邻接多重表                                    */
/************************************************************************/
typedef enum { unvisted,visted } VisitIf;
typedef struct EBox {
     VisitIf       mark;      // 访问标记
     int      ivex, jvex;
                    //该边依附的两个顶点的位置
     struct EBox  *ilink, *jlink;
     InfoType     *info;          // 该边信息指针
} EBox;

typedef struct VexBox {
   VertexType  data;
   EBox  *firstedge; // 指向第一条依附该顶点的边
} VexBox;

typedef struct {  // 邻接多重表
    VexBox  adjmulist[MAX_VERTEX_NUM];
     int   vexnum, edgenum;   
}AMLGraph;
//---------------------------------------------------------------------
typedef  char ElemType;
typedef struct CSNode {
 ElemType data;
 struct CSNode *firstchild,*nextsibling;
}CSNode,*CSTree;

//-----------------------------------------------------------
#define  STACK_INIT_SIZE  100
#define  STACKINCREMENT  10
typedef struct {
 int  *base; //栈底指针  
 int  *top;  //栈顶指针
 int  stacksize;    //栈的大小
} SqStack;
int InitStack (SqStack &S){  
 S.base=(int *)malloc(STACK_INIT_SIZE * sizeof(int));
 if (!S.base)  
 return(0);
 S.stacksize = STACK_INIT_SIZE ;
 S.top = S.base;
 return(1);
}
bool StackEmpty (SqStack S){  
 if(S.base==S.top)
  return(true);//栈空的条件
 return(false);
}
int Pop(SqStack &S, int &e){  
 if(S.base==S.top)
  return(0);//栈空
 //e=*--S.top;
 S.top--;
 e=*S.top;
 return(1);
}
int Push(SqStack &S, int e){  
 if(S.top-S.base>= S.stacksize) {//栈满，申请存储空间
  S.base=(int *)realloc(S.base,(S.stacksize+STACKINCREMENT) * sizeof(int));
  if (!S.base)
   return (0);
  S.stacksize += STACKINCREMENT ;
 }
 *S.top=e ;
 S.top++;
 return(1);
}

 

//-----------------------------------------------------------
//---------------------------------------------------------
typedef struct QNode {
 int data;
 struct QNode *next;
}QNode, *QueuePtr;
typedef struct  {
 QueuePtr front;
 QueuePtr rear;
}LinkQueue;

void InitQueue(LinkQueue &Q){
 Q.front=Q.rear=NULL;
}
bool QueueEmpty(LinkQueue Q){
 if(!Q.front)
  return(true);
 return false;
}
void EnQueue(LinkQueue &Q, int e){
 QNode *p=(QNode *)malloc(sizeof(QNode));
 if (!p)
  return;
 p->data= e, p->next=NULL;
 if(Q.front )
 {
  Q.rear->next=p;Q.rear=p;
 }else
  Q.front = Q.rear=p;
}
void DeQueue(LinkQueue &Q,int &e){
 QNode *p;
 if( !Q.front) return;
 p=Q.front;
 e=p->data;
 Q.front=p->next;
 free(p);
 if(!Q.front) Q.rear=NULL;
}

//----------------------------------------------------------------------
//---------------------------------------------------------------------------------
#define INT_MAX 100
/************************************************************************/
/*                         查看一个节点在邻接表中的位置             */
/************************************************************************/
int LocateVex(ALGraph G,char v){
 for(int i = 0; i < G.vexnum; i++){
  if(G.vertices[i].data == v) return(i);
 }
 return(-1);
}
/************************************************************************/
/*                       创建表                                         */
/************************************************************************/
void CreateALGraph(ALGraph &G){
 printf("请输入节点数和边数:  /n");
 fflush(stdin);
 scanf("%d%d",&G.vexnum,&G.arcnum);
 for(int i=0;i<G.vexnum;i++){
  printf("请输入第%d个顶点的信息：/n",(i+1));
  fflush(stdin);
  scanf("%c",&G.vertices[i].data);
  G.vertices[i].firstarc=NULL;
 }//输入顶点信息
 for(int j=0;j<G.arcnum;j++){   //输入边的信息
  char v,w;
  printf("请输入第%d条弧先关联的两个顶点：/n",j+1);
  fflush(stdin);
  scanf("%c%c",&v, &w);//形式2
  ArcNode *p;
  p=new ArcNode;//建立结点
  if(!p) {
   printf("建立节点失败！！！");
      return ;
  }
  printf("请输入该弧的权值：/n");
  fflush(stdin);
  scanf("%d",&p->weight);//形式2
  p->adjvex=LocateVex(G,w);
  p->nextarc=G.vertices[LocateVex(G,v)].firstarc;
  G.vertices[LocateVex(G,v)].firstarc=p;
 }
}
/************************************************************************/
/*                          打印邻接表                                  */
/************************************************************************/ 
void printALGraph(ALGraph G){
 for(int i=0;i<G.vexnum;i++){
  printf("%c",G.vertices[i].data);
  printf("   ");
  while(G.vertices[i].firstarc!=NULL){
   //cout<<G.vertices[i].firstarc->adjvex<<"  ";
   printf("%c",G.vertices[G.vertices[i].firstarc->adjvex]);
   printf("   ");
   G.vertices[i].firstarc=G.vertices[i].firstarc->nextarc;
  }
  printf("/n");
 }
}
void Convert(ALGraph A,OLGraph &G){
 G.length=G.vexnum=A.vexnum;
 G.arcnum=A.arcnum;
 for(int i=0;i<G.length;i++){
  G.xlist[i].data=A.vertices[i].data;
  G.xlist[i].use=1;
  G.xlist[i].firstin=G.xlist[i].firstout=NULL;
 }
 
 ArcNode *arcNode;
 ArcBox  *arcBox;
 for(i = 0; i < G.length; i++){      
  arcNode = A.vertices[i].firstarc;
  while(arcNode){
   arcBox = (ArcBox *)malloc(sizeof(ArcBox));
   if(!arcBox) exit(1);
   arcBox->tailvex = i;
   arcBox->headvex = arcNode->adjvex;
   arcBox->tlink = G.xlist[arcBox->tailvex].firstout;
   arcBox->hlink = G.xlist[arcBox->headvex].firstin;
   G.xlist[arcBox->tailvex].firstout = G.xlist[arcBox->headvex].firstin = arcBox;
   arcNode = arcNode->nextarc;
  }
 }

}
/************************************************************************/
/*                         点u到其余各顶点的最短路径                    */
/************************************************************************/
int prev[INT_MAX];//prev[v]表示从源s到顶点v的最短路径上顶点的前驱顶点。
bool P[INT_MAX][INT_MAX]; //p[i][w]为true时w为v到i当前求的最短路径上的顶点
int D[INT_MAX];   //D[w]存放顶点w的权值

//得到边<i,j>的权值
int getWei(ALGraph G,int i,int j){
 ArcNode *s;
 s=G.vertices[i].firstarc;
 // printf("边的起点%d/n",i);
 while(s&&s->adjvex!=j){
  //  printf("找边%d/n",s->adjvex);
  s=s->nextarc;
 }
 if(s)  
  return s->weight;
 else   
  return INT_MAX;
}

void ShortestPath_DIJ(ALGraph G,int v){
 int i=0,j,v0,w,min;
    bool final[INT_MAX];    //当final[w]为true，已经求的从v到w得最短路径
 for(v0=0;v0<G.vexnum;v0++){
  prev[v0]=-1;
  final[v0]=false;
  //  printf("初始化/n");
  D[v0]=getWei(G,v,v0);
  for(w=0;w<G.vexnum;++w)   P[v0][w]=false;   // 设空路径
  if(D[v0]<INT_MAX){ //顶点i与源点v邻接
   prev[v0]=v;
   P[v0][v]=true;  
   P[v0][v0] =true;
  }
 }
 D[v]=0;   final[v]=true;
 //主循环，每次求得v0到某个顶点v的最短路径，并将v加到S集中
 for(i=1;i<G.vexnum;++i){
  //当前所知离v顶点的最近距离
        min=INT_MAX;
        for(w=0;w<G.vexnum;++w){
   if(!final[w])
    if(D[w]<min){
     v0=w;   min=D[w];
    }
  }
  if(v0==G.vexnum){
   break;
  }
  final[v0]=true;      //更新当前最短路径及距离
  for(w=0;w<G.vexnum;++w)
   if(!final[w]&&(min+getWei(G,v0,w)<D[w])){
    prev[w]=v0;
    D[w]=min+getWei(G,v0,w);
    for(j=0;j<G.vexnum;j++) P[w][j]=P[v0][j];
    P[w][w]=true;
   }
 }
}
//-----------输出最短路径
void printPath(ALGraph G,int v){
 int i,k;
 SqStack s;
 InitStack(s);
    int a;
 for(i=0;i<G.vexnum;i++){
  if(i!=v){
   if(D[i]!=INT_MAX){
    printf("%c到%c的最短路径长度为:%d/n",G.vertices[v].data,G.vertices[i].data,D[i]);
    printf("%c到%c的最短路径为：",G.vertices[v].data,G.vertices[i].data);
    Push(s,i);
    for(k=prev[i];k>-1;k=prev[k]){
     a=G.vertices[k].data;
     Push(s,k);
    }
    while(!StackEmpty(s)){
     Pop(s,a);
     printf("%c/t",G.vertices[a].data);
    }
    printf("/n");
   }
   else
    printf("%c到%c不存在最短路径/n",G.vertices[v].data,G.vertices[i].data);
  }
 }
}

//--------------------任两点间的最短路径----------------------
void AllShortestPath(ALGraph G){
 int i;
 for(i=0;i<G.vexnum;i++){
  ShortestPath_DIJ(G,i);
  printPath(G,i);
 }
}

//---------------------------------------------------------------------------------
/************************************************************************/
/*                查看一个节点在十字链表中的位置                        */
/************************************************************************/
int LocateVex(OLGraph G,VertexType v){
 for(int i = 0; i < MAX_VERTEX_NUM; i++){
  if(G.xlist[i].data == v) {
   if(G.xlist[i].use==0){
    printf("该节点已被删除！！！");
    return(-1);
   }else
    return(i);
  }
 }
 return(-1);
}
/************************************************************************/
/*                    采用十字链表存储表示，构造有向图                  */
/************************************************************************/
void CreateOLGraph(OLGraph &G){     
 printf("请输入节点数和边数:  /n");
 fflush(stdin);                              //清空缓冲
 scanf("%d%d",&G.vexnum, &G.arcnum);
 printf("/n");
 int i;
 for(i = 0; i < G.vexnum; i++){    //输入顶点，按照输入的先后次序存放到数组中
  printf("请输入第%d节点值:  /n",i);
  fflush(stdin); 
  scanf("%c", &G.xlist[i].data);
  printf("/n");
  G.xlist[i].firstin = G.xlist[i].firstout = NULL;
  G.xlist[i].use=1;
 }
 printf("/n");
 VertexType tail, head;
 ArcBox *arcNode;
 for(i = 0; i < G.arcnum; i++){
  printf("请输边的起始点: /n");
  fflush(stdin);       //清空缓冲
  scanf("%c%c", &tail, &head);
  printf("请输入改变的权值: /n");
  fflush(stdin); 
  arcNode = (ArcBox *)malloc(sizeof(ArcBox));
  if(!arcNode) exit(1);
  arcNode->tailvex = LocateVex(G, tail);
  arcNode->headvex = LocateVex(G, head);
  scanf("%d",&arcNode->weight);
  arcNode->tlink = G.xlist[arcNode->tailvex].firstout;
  arcNode->hlink = G.xlist[arcNode->headvex].firstin;
  G.xlist[arcNode->tailvex].firstout = G.xlist[arcNode->headvex].firstin = arcNode;
 }
 G.length=G.vexnum;
}
/************************************************************************/
/*             计算节点的出度                                           */
/************************************************************************/
int outDegree(OLGraph G, VertexType vex)
{
 
 int count=0;
 int vertex = LocateVex(G, vex);
 if(G.xlist[vertex].use==0){
  printf("该节点已被删除！！！");
  return(-1); 
 }
 ArcBox *p;
 p = G.xlist[vertex].firstout;
 while(p){
  count++;
  p = p->tlink;
 }
 return(count);
}
/************************************************************************/
/*             计算节点的入度                                           */
/************************************************************************/
int inDegree(OLGraph G, VertexType vex)
{
 int count=0;
 int vertex = LocateVex(G, vex);
 if(G.xlist[vertex].use==0){
  printf("该节点已被删除！！！");
  return(-1); 
 }
 ArcBox *p;
 p = G.xlist[vertex].firstin;
 while(p){
  count++;
  p = p->hlink;
 }
 return(count);
}
/************************************************************************/
/*                             插入顶点                                 */
/************************************************************************/
bool InsertVex(OLGraph &G, VertexType vex){
 if(G.length==MAX_VERTEX_NUM){
  return false;
 }else{
  G.xlist[G.length].data=vex;
  G.xlist[G.length].use=1;
  G.xlist[G.length].firstin = G.xlist[G.length].firstout = NULL;
  G.vexnum++;
  G.length++;
  return true;
 }
}

/************************************************************************/
/*                             插入弧                                  */
/************************************************************************/
bool InsertArc(OLGraph &G, VertexType vex1, VertexType vex2){
 if ((G.xlist[LocateVex(G, vex1)].use==0)||(G.xlist[LocateVex(G, vex2)].use==0))
 {
  printf("要插入的弧对应的节点不存在！！！");
  return false;
 }
 ArcBox *arcNode = (ArcBox *)malloc(sizeof(ArcBox));
 if(!arcNode) exit(1);
 arcNode->tailvex = LocateVex(G, vex1);
 arcNode->headvex = LocateVex(G, vex2);
 arcNode->tlink = G.xlist[arcNode->tailvex].firstout;
 arcNode->hlink = G.xlist[arcNode->headvex].firstin;
 G.xlist[arcNode->tailvex].firstout = G.xlist[arcNode->headvex].firstin = arcNode;
 G.arcnum++;
 return true;
}

/************************************************************************/
/*                             删除弧                                   */
/************************************************************************/

bool DeleteArc(OLGraph &G, VertexType vex1, VertexType vex2){
 if ((G.xlist[LocateVex(G, vex1)].use==0)||(G.xlist[LocateVex(G, vex2)].use==0))
 {
  printf("要删除的弧对应的节点不存在！！！");
  return false;
 }
 ArcBox *arcNode1;
 ArcBox *arcNode2;
 arcNode1=G.xlist[LocateVex(G, vex1)].firstout;
 if(arcNode1&&(arcNode1->tailvex==LocateVex(G, vex1))&&
  (arcNode1->headvex==LocateVex(G, vex2)))
 {
  arcNode2=arcNode1;
  G.xlist[LocateVex(G, vex1)].firstout=arcNode1->tlink;
 }else{
  while(arcNode1->tlink)
  {   
   if((arcNode1->tlink->tailvex==LocateVex(G, vex1))&&
    (arcNode1->tlink->headvex==LocateVex(G, vex2)))
   {
    arcNode2=arcNode1->tlink;
    arcNode1->tlink=arcNode1->tlink->tlink;
   }else
   {
    arcNode1=arcNode1->tlink;
   }
  }
 }
 arcNode1=G.xlist[LocateVex(G, vex2)].firstin;
 if(arcNode1&&(arcNode1->tailvex==LocateVex(G, vex1))&&
  (arcNode1->headvex==LocateVex(G, vex2)))
 {
  arcNode2=arcNode1;
  G.xlist[LocateVex(G, vex2)].firstin=arcNode1->hlink;
 }else{
  while(arcNode1->hlink)
  {   
   if((arcNode1->hlink->tailvex==LocateVex(G, vex1))&&
    (arcNode1->hlink->headvex==LocateVex(G, vex2)))
   {
    arcNode2=arcNode1->hlink;
    arcNode1->hlink=arcNode1->hlink->hlink;
   }else{
    arcNode1=arcNode1->hlink;
   }
  }
 }
 G.arcnum--;
 free(arcNode2);
 return true;
}

/************************************************************************/
/*                             删除顶点                                 */
/************************************************************************/
bool DeleteVex(OLGraph &G, VertexType vex){
 int x = LocateVex(G, vex);
 ArcBox *arcNode1;
 VertexType vex1;
 arcNode1=G.xlist[x].firstout;
 while(arcNode1){
  vex1=G.xlist[arcNode1->headvex].data;
  DeleteArc(G,vex,vex1);
  arcNode1=G.xlist[x].firstout;
 }
 arcNode1=G.xlist[x].firstin;
 while(arcNode1){
  vex1=G.xlist[arcNode1->tailvex].data;
  DeleteArc(G,vex1,vex);
  arcNode1=G.xlist[x].firstin;
 }
 G.xlist[x].use=0;
 G.vexnum--;
 return true;
}

/************************************************************************/
/*                      广度优先搜索—非连通图                          */
/************************************************************************/
bool visited[MAX_VERTEX_NUM];
ArcBox *nextArc=NULL;
int firstAdjvex(OLGraph G, int ivex)
{
 if(!G.xlist[ivex].firstout) return(-1);//无邻接点
 nextArc = G.xlist[ivex].firstout->tlink;
 return(G.xlist[ivex].firstout->headvex);

}
int nextAdjvex(OLGraph G)
{
 if(!nextArc) return(-1);
 int i = nextArc->headvex;
 nextArc = nextArc->tlink;
 return(i);
}
void BFSTraverse(OLGraph G){
 LinkQueue Q;
 for (int v=0; v<G.vexnum; ++v)
  visited[v] = false;  //初始化访问标志
 InitQueue(Q);       // 置空的辅助队列Q
 for ( v=0;  v<G.vexnum;  ++v )
  if ( !visited[v]) {          // v 尚未访问
   visited[v] = true; 
   printf("%c",G.xlist[v].data) ;
   printf("  "); // 访问u
   EnQueue(Q, v);             // v入队列
   while (!QueueEmpty(Q))  {
    int u;
    DeQueue(Q, u);        // 队头元素出队并置为u
    for(int w=firstAdjvex(G, u); w>=0; w=nextAdjvex(G))
     if ( ! visited[w])  {
      visited[w]=true; 
      printf("%c",G.xlist[w].data) ;
      printf("  "); // 访问u
      EnQueue(Q, w); // 访问的顶点w入队列
     } // if
   } // while

  }
} // BFSTraverse

/************************************************************************/
/*                    深度优先搜索—非连通图                            */
/************************************************************************/

void DFS(OLGraph G, int v) {
   // 从顶点v出发，深度优先搜索遍历连通图 G
    visited[v] = true;
 //cout<<G.xlist[v].data<<"  ";
 printf("%c",G.xlist[v].data);
 printf("   ");
    for(int w=firstAdjvex(G, v);w>=0; w=nextAdjvex(G))
        if (!visited[w])  DFS(G, w);    
         // 对v的尚未访问的邻接顶点w递归调用DFS
}
void DFSTraverse(OLGraph G) {
     for (int v=0; v<G.vexnum; ++v)
               visited[v] = false; // 访问标志数组初始化
     for (v=0; v<G.vexnum; ++v) {
         if (!visited[v])  DFS(G, v);   // 对尚未访问的顶点调用DFS              
     }
}
/************************************************************************/
/*                   深度优先的生成树                                   */
/************************************************************************/
int FirstAdjvex(OLGraph G, int ivex)
{
 nextArc=G.xlist[ivex].firstout;
b: if(!nextArc) return(-1);//无邻接点
 int x = nextArc->headvex;
 
 if(visited[x]){
  nextArc=nextArc->tlink;
  goto b;
 }
 nextArc = G.xlist[x].firstout;
 return(x);

}
int NextAdjvex(OLGraph G){
a: if(!nextArc) return(-1);//无邻接点
 int x = nextArc->headvex;
 if(visited[x]) {
  nextArc=nextArc->tlink;
  goto a;
 }
 nextArc=G.xlist[x].firstout;
 return(x); 
}

void DFSTree(OLGraph G,int v, CSTree &T){
 visited[v]=true;
 bool first = true;
 CSTree q;
 for(int w =FirstAdjvex(G,v);w>=0;w=NextAdjvex(G))
 {
  if(!visited[w]){
   CSTree p = (CSTree)malloc(sizeof(CSNode));
   p->data=G.xlist[w].data;
   p->firstchild=p->nextsibling=NULL;
   if(first){
    T->firstchild=p;
    first=false;
   }else{
    q->nextsibling=p;
   }
   q=p;
   DFSTree(G,w,q);
  }
 }

}
void DFSForset(OLGraph G,CSTree &T){
 T=NULL;
 CSTree q;
 for (int v=0;v<G.vexnum;v++)
  visited[v]=false;
 for (v =0;v<G.vexnum;v++) {
  if(!visited[v]){
   CSTree p = (CSTree)malloc(sizeof(CSNode));
   p->data=G.xlist[v].data;
   p->firstchild=p->nextsibling=NULL;
   if(!T){
    T=p;
   }else{
    q->nextsibling=p;
   }
   q=p;
   DFSTree(G,v,p);
  }
 }
}
/************************************************************************/
/*                   孩子兄弟二叉树遍历                                 */
/************************************************************************/
void PreOrderTreeset(CSTree T){
 if(T){
  printf("%c",T->data);
  printf("  ");
  PreOrderTreeset(T->firstchild);
  PreOrderTreeset(T->nextsibling);
 }
}

/************************************************************************/
/*                            关键路径                                  */
/************************************************************************/
int indegree[MAX_VERTEX_NUM];
int ve[MAX_VERTEX_NUM];
int vl[MAX_VERTEX_NUM];
SqStack T;
SqStack S;
bool TopologicalSort(OLGraph G,SqStack &T){
 for(int i=0;i<G.vexnum;i++){
  indegree[i]=inDegree(G,G.xlist[i].data);
 }
 InitStack(S);
 for (i=0;i<G.vexnum;i++)
 {
  if(indegree[i]==0)
   Push(S,i);
  ve[i]=0;
 }
 int count=0;
 int k;
 while(!StackEmpty(S)){
  Pop(S,i);
  Push(T,i);
  printf("%c",G.xlist[i].data);
  count++;
  ArcBox *p;
  for(p=G.xlist[i].firstout;p;p=p->tlink){
   k=p->headvex;
   if(!(--indegree[k]))
    Push(S,k);
   if(ve[i]+p->weight>ve[k])
    ve[k]=ve[i]+p->weight;
  }
 }
 printf("/n");
 if(count<G.vexnum)
  return false;
 return true;
}

void CriticalPath(OLGraph G){
 int j,k,dut,ee,el;
 char tag;
 ArcBox *p;
 InitStack(T);
 if(!TopologicalSort(G,T)){ 
  printf("该图存在环/n");
  return;
 }
 for(int i=0;i<G.vexnum;i++){
  vl[i]=ve[G.vexnum-1];
 }
 while(!(StackEmpty(T))){
  for (Pop(T,j),Push(S,j),p=G.xlist[j].firstout;p;p=p->tlink) {
   k=p->headvex;
   dut=p->weight;
   if(vl[k]-dut<vl[j]){
    vl[j]=vl[k]-dut;
   }
  }
 }
 while (!StackEmpty(S)) {
  Pop(S,i);
  if(vl[i]==ve[i])
   printf("%c",G.xlist[i].data);
 }

}

//---------------------------------------------------------------------------------

OLGraph G;
ALGraph A;
VertexType e;
VertexType f;
CSTree t;
 

void out(){
 for(int i = 0; i < G.length; i++){
  if(G.xlist[i].use==0){
   i++;
  }
  int din = inDegree(G, G.xlist[i].data);
  int dout = outDegree(G, G.xlist[i].data);
  printf("节点=%c  入度=%d  出度=%d/n", G.xlist[i].data,din,dout);
 }
}

void Loop(OLGraph G){
 for(int i=0;i<G.vexnum;i++){
  indegree[i]=inDegree(G,G.xlist[i].data);
 }
 InitStack(S);
 for (i=0;i<G.vexnum;i++)
 {
  if(indegree[i]==0)
   Push(S,i);
 }
 int count=0;
 int k;
 while(!StackEmpty(S)){
  Pop(S,i);
  printf("%c",G.xlist[i].data);
  count++;
  ArcBox *p;
  for(p=G.xlist[i].firstout;p;p=p->tlink){
   k=p->headvex;
   if(!(--indegree[k]))
    Push(S,k);
  }
 }
 printf("/n");
 if(count<G.vexnum)
  printf("该图存在回路/n");
 else
  printf("该图不存在回路/n");
 
}

 

int mune1(){
 CreateOLGraph(G);
 printf("                               创建有向图(十字链表)/n");
 printf("                     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/n");
 printf("                     &             命令菜单             &/n");
 printf("                     & -------------------------------- &/n");
 printf("                     &     1---求每个顶点的入度和出度   &/n");
 printf("                     &     2---插入顶点                 &/n");
 printf("                     &     3---删除顶点                 &/n");
 printf("                     &     4---插入弧                   &/n");
 printf("                     &     5---删除弧                   &/n");
 printf("                     &     0---返回上一层               &/n");
 printf("                     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/n");
A1: printf("请输入要选择的操作/n**");
 int code1;
 scanf("%d",&code1);
 switch(code1){
 case 1:
  out();
  break;
 case 2:
  printf("请输入要插入节点的值：/n");
  fflush(stdin); 
  scanf("%c",&e);
  InsertVex(G,e);
  out();
  break;
 case 3:
  printf("请输入要删除节点的值：/n");
  fflush(stdin); 
  scanf("%c",&e);
  DeleteVex(G,e);
  out();
  break;
 case 4:
  printf("请输入要插入的弧的起始点：/n");
  fflush(stdin); 
  scanf("%c%c",&e,&f);
  InsertArc(G,e,f);
  out();
  break;
 case 5:
  printf("请输入要删除的弧的起始点：/n");
  fflush(stdin); 
  scanf("%c%c",&e,&f);
  DeleteArc(G,e,f);
  out();
  break;
 case 0:
  return 0;
 default:
  printf("输入的指令有误！请重新输入：");
  goto A1;
 }
 goto A1;
 return 1;
};
int mune2(){
 CreateALGraph(A);
 printf("                              创建有向图(邻接矩阵)/n");
 printf("                     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/n");
 printf("                     &             命令菜单             &/n");
 printf("                     & -------------------------------- &/n");
 printf("                     &   1---转化为十字链表存储结构     &/n");
 printf("                     &   2---对深度优先生成森林进行遍历 &/n");
 printf("                     &   3---判断图中是否存在环         &/n");
 printf("                     &   4---顶点u到其余各点的最短路径  &/n");
 printf("                     &   5---任两个顶点之间的最短路径   &/n");
 printf("                     &   6---求关键路径                 &/n");
 printf("                     &   0---返回上一层                 &/n");
 printf("                     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/n"); 
A2: printf("请输入要选择的操作/n**");
 int code2;
 scanf("%d",&code2);
 switch(code2){
 case 1:
  Convert(A,G);
  out();
  break;
 case 2:
  DFSForset(G,t);
  PreOrderTreeset(t);
  printf("/n");
  break;
 case 3:
  Loop(G);
  break;
 case 4:
  char in;
  printf("请输入要顶点v：/n");
  fflush(stdin);
  scanf("%c",&in);
  ShortestPath_DIJ(A,LocateVex(A,in));
  printPath(A,LocateVex(A,in));
  break;
 case 5:
  AllShortestPath(A);
  break;
 case 6:
  CriticalPath(G);
  break;
 case 0:
  return 0;
 default:
  printf("输入的指令有误！请重新输入：");
  goto A2;
 }
 goto A2;
 return 1;
};
int main(int argc, char* argv[])
{
 
main: printf("                               数据结构课程设计/n");
 printf("                     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/n");
 printf("                     &             命令菜单             &/n");
 printf("                     & -------------------------------- &/n");
 printf("                     &     1--创建有向图(十字链表)      &/n");
 printf("                     &     2--创建有向图(邻接矩阵)      &/n");
 printf("                     &         0--------退出            &/n");
 printf("                     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/n");
 printf("请输入要选择的操作/n**");
 int code;
A: scanf("%d",&code);
 switch(code){
 case 1:
  if(mune1()==0)
   goto main;
  break;
 case 2:
  if(mune2()==0)
   goto main;
  break;
 case 0:
  return 0;
 default:
  printf("输入的指令有误！请重新输入：");
  goto A;
 }
 return 0;
}