四：图-邻接表的初始化操作及应用

表结点的形式

typedef struct ArcNode{
    int adjvex;                   //邻接点的下标
    struct ArcNode *nextarc;
  //  InfoType *info;
}ArcNode;

顶点的存储形式

typedef struct VNode{
    char data;
    ArcNode *firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];  //以数组的形式进行存储的，就像是合成了一个表

图的结构:两部分

typedef struct{
    AdjList vertices;
    int vexnum;
    int arcnum;
    int kind;
}ALGraph;

找到顶点的下标位置

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 CreatGraph(ALGraph &G){
    cout<<"请输入图的类型：0表示有向，1表示无向"<<endl;
    cin>>G.kind;
    cout<<"请输入顶点的数目和边的数目："<<endl;
    cin>>G.vexnum>>G.arcnum;
    for(int i=0;i<G.vexnum;i++){
        cout<<"请输入第"<<i+1<<"个顶点"<<endl;
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc=NULL;
    }


    ArcNode *p;
    ArcNode *q;

    for(int k=0;k<G.arcnum;k++){
        char v1,v2;
        cout<<"请顺序输入边的两个邻接点"<<endl;
        cin>>v1>>v2;
        int i=LocateVex(G,v1);
        int j=LocateVex(G,v2);

        p=(ArcNode*)malloc(sizeof(ArcNode));
        p->adjvex=j;
        p->nextarc=G.vertices[i].firstarc; //头插法
        G.vertices[i].firstarc=p;

        if(G.kind==1){
        q=(ArcNode*)malloc(sizeof(ArcNode));
        q->adjvex=i;
        q->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=q;

        }
    }
}

创建网

void CreatNet(ALGraph &G){
}

搜索算法：深度搜索

int visited[20];

//-------存储边对结构：（A,B）即遍历的顺序过程记录--------
typedef struct{
	char start;
	char end;
}Arc;
Arc BSet[20];    //广度优先搜索生成的边的边集
Arc DSet[20];   //深度优先搜索生成的边的边集
int b = 0;  //广度优先搜索边集的index
int d = 0;  //深度优先搜索边集的index

创建无向图

//------------创建无向图：邻接表形式---------
void createGraph(ALGraph &G){
    cout<<"请输入图的顶点的个数："<<endl;
	cin>>G.vexnum;
	cout<<"请输入图的边的个数："<<endl;
	cin>>G.arcnum;

	cout<<"请输入顶点的信息"<<endl;
	for (int i = 0; i<G.vexnum; i++){
            cin>>G.vertices[i].data;
           G.vertices[i].firstarc = NULL;
	}

	cout<<"请输入边的邻接顶点的信息："<<endl;
     char v1, v2;
	for (int j = 0; j<G.arcnum; j++){
        cin>>v1>>v2;
        int i=LocateVex(G,v1);
        int j=LocateVex(G,v2);
        ArcNode *s;
		s = (ArcNode*)malloc(sizeof(ArcNode));
		s->adjvex = i;
		s->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = s;

		s = (ArcNode*)malloc(sizeof(ArcNode));
		s->adjvex = j;
		s->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = s;
	}
}

深度优先遍历

//-----------深度优先遍历-------------
void DFS(ALGraph G, char v){
	//以i为开始开始遍历
	int i =LocateVex(G,v);
	cout<<v;
    visited[i] = 1; //0为假，1为真


	ArcNode *p,*q;
	p = G.vertices[i].firstarc;

	while (p){
            //------一个P代表一个深度：：：----------
		if (!visited[LocateVex(G,G.vertices[p->adjvex].data)]){
			DSet[d].start = v;
			DSet[d].end = G.vertices[p->adjvex].data;
			d++;
			DFS(G, G.vertices[p->adjvex].data); //----重点在这里----
		}
		p = p->nextarc;
	}
}
//-----------深度优先遍历开始------------
void DFSTraverse(ALGraph G){
	char v;
	cout<<"请输入从哪个点开始进行深度优先搜索"<<endl;
	cin>>v;
	int j=LocateVex(G,v);
	printf("深度优先搜索遍历顺序为：");
	for (int i = 0; i<G.vexnum; i++){
		visited[i] = 0;
	}
	for (int i = j; i<G.vexnum; i++){
		if (!visited[i]){
			DFS(G, G.vertices[i].data);
		}
	}
	for (int i = 0; i<j; i++){
		if (!visited[i]){
			DFS(G, G.vertices[i].data);
		}
	}
	printf("\n");
}
//-----深度打印---------
void PrintDFTree(ALGraph G){
	printf("深度生成树的边集为：");
	for (int i=0; i < G.vexnum - 1; i++){
            cout<<"("<<DSet[i].start<<","<<DSet[i].end<<")";
	}
	printf("\n");
}

广度优先遍历

//----------广度优先遍历------------
typedef struct QNode{
	char data;
	struct QNode* next;
}QNode, *QuePtr;

typedef  struct {
	QuePtr front;
	QuePtr rear;
}LinkQue;


int Init(LinkQue &Q){
	Q.front = Q.rear = (QuePtr)malloc(sizeof(QNode));
	if (!Q.front) return -1;
	Q.front->next = NULL;  //不要忘了把头结点的next手动定义为null
	//	printf("success in initializating.\n");
	return 0;
}

int enQue(LinkQue &Q, char e){
	QNode *p = (QNode*)malloc(sizeof(QNode));
	if (!p) return -1;
	p->data = e;
	p->next = NULL;  //别忘了null
	Q.rear->next = p;
	Q.rear = p;
	return 0;
}

int deQue(LinkQue &Q, char &e){
	if (Q.front == Q.rear){
		printf("The queue is empty now.\n");
		return -1;
	}
	QNode* p = Q.front->next;  //Q.front 是一个没有存放任何东西的头结点
	e = p->data;
	//printf("The data is %d\n",e);
	Q.front->next = p->next;
	if (Q.rear == p) Q.rear = Q.front; //队列中只有一个元素的情况 先把rear挪到前面来 要不然删的话把rear也一起删掉了
	free(p);
	return 0;
}

void BFS(ALGraph G, char v){
    cout<<v;
    int i =LocateVex(G,v);

	visited[i] = 1;
	LinkQue Q;
	char e;
	Init(Q);
	enQue(Q, v);
	while (Q.front != Q.rear){
		deQue(Q, v);
		ArcNode *p = G.vertices[LocateVex(G,v)].firstarc;
		while (p){
			if (!visited[LocateVex(G,p->adjvex)]){
              //      cout<<G.vertices[p->adjvex].data;
                //    cout<<p->adjvex;
				visited[LocateVex(G,p->adjvex)] = 1;
				enQue(Q, p->adjvex);
				BSet[b].start = v;
            //    BSet[b].end=G.vertices[p->adjvex].data;
				BSet[b].end = p->adjvex;
				cout<<BSet[b].end;
				b++;
			}
			p = p->nextarc;
		}
	}
}

void BFSTraverse(ALGraph G){
	int i, j;
	printf("请输入从哪个点开始进行广度优先搜索。\n");
	char v;
	cin>>v;
	j=LocateVex(G,v);
	printf("广度优先搜索遍历顺序为：\n");
	for (i = 0; i<G.vexnum; i++){
		visited[i] = 0;
	}
	for (i = j; i<G.vexnum; i++){
		if (!visited[i]){
			BFS(G, G.vertices[i].data);
		}
	}
	for (i = 0; i<j; i++){
		if (!visited[i]){
			BFS(G, G.vertices[i].data);
		}
	}
	printf("\n");
}

void PrintBFTree(ALGraph G){
	int i = 0;
	printf("广度生成树的边集为：\n");
	for (; i < G.vexnum - 1; i++){
            cout<<"("<<BSet[i].start<<","<<BSet[i].end<<")";

		//printf("(%d,%d)\t", BSet[i].start, BSet[i].end);
	}
	printf("\n");
}