数据结构 图 结构及算法

p = g->Graphvex[k].firstAdjoin;
while (p)
{
i = p->index;
closedge[i].vex = GetVexName(g,k);
closedge[i].w = p->weight;
p = p->nextAdjoin;
if (p->weight < closedge[j].w)
{
closedge[j].vex = GetVexName(g, k);
closedge[j].w = p->weight;
}
p = p->nextAdjoin;
}
if (visited[u] == 0)
{
quene[r] = u;
r = (r + 1) % (n + 1);
visited[u] = 1;
printf("->%d", u+1);
}
p = p->nextAdjoin;
{
printf("->%d", w + 1);
visited[w] = 1;
DSF(g, w, visited);
}
p = p->nextAdjoin;
}
}
void BFSTraverse(Graph* g)
{
int v = 0;
{
min = closedge[i].w;
p = i;
}
}
return p;
}
void Findindegree(Graph* g, int indegree[]);
void TopologicalSort(Graph*g)
{
int n = g->vexNum;
p->index = j;
p->weight = w;
p->nextAdjoin = g->Graphvex[i].firstAdjoin;
g->Graphvex[i].firstAdjoin = p;
if (GraphStyle == NODIGIGRAPH)
{
void DFSTraverse(Graph*g)
{
int v = 0;
int w = 0;
int n = g->vexNum;
int* visited = new int[n];
for (v = 0; v < n; v++)
{
visited[v] = 0;
}
}
}
delete[] closedge;
}
int MinWeight(cd closedge[],int n)
{
int i = 0;
int p = -1;
int min = INT_MAX;
for (i = 0; i < n; i++)
{
if (closedge[i].w != 0 && closedge[i].w < min)
void Prim(Graph*g,char vex)
{
adjoin*p=NULL;
int k = 0;
int i = 0;
int j = 0;
int n = g->vexNum;
cd*closedge = new cd[n];
k = GetIndex(g, vex);
{
if (g->Graphvex[i].vexname == v)
{
break;
}
}
if (i >= g->vexNum)
{
g->Graphvex[g->vexNum].vexname = v;
g->vexNum++;
return 1;
}
g->Graphvex[i].vexname = ' ';
}
g->vexNum = 0;
g->edgeNum = 0;
}
int InsertVex(Graph* g, char v)
{
int i = 0;
for (i = 0; i < g->vexNum; i++)
{
visited[v] = 0;
}
r = 0, f = 0;
for (v = 0; v < n; v++)
{
if (visited[v] == 0)
{
quene[r] = v;
r = (r + 1) % (n + 1);
visited[v] = 1;
// datastructure.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
#include<string.h>
{
if (g->Graphvex[i].vexname == v)
{
break;
}
}
if (i >= g->vexNum)
{
return -1;
}
else
{
return i;
}
}
int InsertEdge(Graph* g, char v1, char v2, int w,int GraphStyle=DIGRAPH)
p = (adjoin*)malloc(sizeof(adjoin));
p->index = i;
p->weight = w;
p->nextAdjoin = g->Graphvex[j].firstAdjoin;
g->Graphvex[j].firstAdjoin = p;
}
for (i = 1; i < n; i++)
{
k = MinWeight(closedge, n);
closedge[k].w = 0;
p = g->Graphvex[k].firstAdjoin;
while (p)
{
j = p->index;
{
adjoin* p=NULL;
int i = 0;
int j = 0;
i = GetIndex(g, v1);
j = GetIndex(g, v2);
if (i == -1 || j == -1)
{
return 0;
}
else
{
p = (adjoin*)malloc(sizeof(adjoin));
}
}
}
printf("\n");
delete[] quene;
delete[] visited;
}
typedef struct cd
{
char vex;
int w;
}cd;
int MinWeight(cd closedge[], int n);
closedge[k].vex = vex;
closedge[k].w = 0;
for (i = 0; i < n; i++)
{
if (i != k)
{
closedge[i].vex = ' ';
closedge[i].w = INT_MAX;
}
}
int weight;
}adjoin;
typedef struct adjoinvex
{ Biblioteka har vexname; adjoin* firstAdjoin;
}adjoinvex;
typedef struct Graph
{
adjoinvex Graphvex[MAX_Vertex_Num];
}
g->edgeNum++;
return 1;
}
}
int GetVexNum(Graph*g)
{
return g->vexNum;
}
int GetEdgeNum(Graph*g)
{
return g->edgeNum;
}
int GetWeight(Graph* g,char vex1, char vex2)
for (v = 0; v < n; v++)
{
if (visited[v] == 0)
{
visited[v] = 1;
printf("%d", v + 1);
DSF(g,v,visited);
}
}
printf("\n");