图练习题

#include<stdio.h>
#include<stdlib.h>
typedef int datatype;
#define maxsize 100
#define inf 1000000000.
int visited[maxsize] = { 0 };
typedef struct node
{
datatype data;
struct node* next;
}node;
typedef struct queue
{
node*rear, *front;
}queue;
typedef struct index
{
int aj;
struct index *next;
double weight;
}index;
typedef struct vertax
{
datatype data;
int in;
int out;
index *link;
}vertax;
typedef struct graph
{
vertax vex[maxsize];
int num;
int edgenum;
}graph;
typedef struct edge
{
int from;
int dest;
double weight;
}edge;
typedef struct graph1
{
vertax vex[maxsize];
int num;
double dist[maxsize][maxsize];
}graph1;
void init_queue(queue*&q)
{
q = (queue*)malloc(sizeof(queue));
q->front = q->rear = (node*)malloc(sizeof(node));
q->front->next = NULL;
}v
oid enqueue(queue *q, datatype data)
{
node *temp = (node*)malloc(sizeof(node));
temp->data = data;
q->rear->next = temp;
q->rear = q->rear->next;
}b
ool empty(queue*q)
{
return q->rear == q->front;
}d
atatype dequeue(queue*q)
{
if (empty(q))
printf("empty queue!\n");
else
{
datatype temp = q->front->next->data;
if (q->front->next == q->rear)
q->rear = q->front;
q->front->next = q->front->next->next;
return temp;
}
} d
atatype getfront(queue*q)
{
if (!empty(q))
return q->front->next->data;
else
printf("empty queue!\n");
}
graph *g;
void create_graph(graph*&g,datatype vexnode[], int from[], int dest[],double weight[], int
vexnum,int edgenum)
{
g = (graph*)malloc(sizeof(graph));
g->num = vexnum;
g->edgenum = edgenum;
for (int i = 0; i < vexnum; i++)
{
g->vex[i].data = vexnode[i];
g->vex[i].link = NULL;
} f
or (int j = 0; j < edgenum; j++)
{
index*p = (index*)malloc(sizeof(index));
p->aj = from[j];
p->weight = weight[j];
p->next = g->vex[dest[j]].link;
g->vex[dest[j]].link = p;
p = (index*)malloc(sizeof(index));
p->aj = dest[j];
p->weight = weight[j];
p->next = g->vex[from[j]].link;
g->vex[from[j]].link = p;
}
} v
oid create_graphd(graph*&g, datatype vexnode[], int from[], int dest[], double weight[], int
vexnum, int edgenum)
{
g = (graph*)malloc(sizeof(graph));
g->num = vexnum;
g->edgenum = edgenum;
for (int i = 0; i < vexnum; i++)
{
g->vex[i].data = vexnode[i];
g->vex[i].link = NULL;
g->vex[i].in = 0;
g->vex[i].out = 0;
} f
or (int j = 0; j < edgenum; j++)
{
index*p = (index*)malloc(sizeof(index));
p->aj = dest[j];
p->weight = weight[j];
p->next = g->vex[from[j]].link;
g->vex[from[j]].link = p;
g->vex[from[j]].out++;
g->vex[dest[j]].in++;
}
} v
oid dfsl(int i)
{
visited[i] = 1;
printf("%d ", g->vex[i].data);
index *p = g->vex[i].link;
while (p != NULL)
{
if (visited[p->aj] == 0)
dfsl(p->aj);
p = p->next;
}
} v
oid bfsl(int i)
{
queue*q;
init_queue(q);
printf("%d ", g->vex[i].data);
index*p = NULL;
visited[i] = 1;
enqueue(q, i);
while (!empty(q) || p != NULL)
{
if (p == NULL)
{
p = g->vex[dequeue(q)].link;
} e
lse
{
if (visited[p->aj] == 0)
{
visited[p->aj] = 1;
printf("%d ", g->vex[p->aj].data);
enqueue(q, p->aj);
} p
= p->next;
}
}
} v
oid create_graph1(graph1*& g,datatype vexnode[],int vexnum,int from [],int dest[], double
weight[],int edgenum)
{
g = (graph1*)malloc(sizeof(graph1));
g->num = vexnum;
for (int i = 0; i < vexnum; i++)
{
g->vex[i].data = vexnode[i];
g->vex[i].link = NULL;
} f
or (int i = 0; i < vexnum; i++)
for (int j = 0; j < vexnum; j++)
g->dist[i][j] = inf;
for (int i = 0; i < edgenum; i++)
{
g->dist[from[i]][dest[i]] = weight[i];
g->dist[dest[i]][from[i]] = weight[i];
}
} v
oid create_graph1d(graph1*& g, datatype vexnode[], int vexnum, int from[], int dest[], double
weight[], int edgenum)
{
g = (graph1*)malloc(sizeof(graph1));
g->num = vexnum;
for (int i = 0; i < vexnum; i++)
{
g->vex[i].data = vexnode[i];
g->vex[i].link = NULL;
} f
or (int i = 0; i < vexnum; i++)
for (int j = 0; j < vexnum; j++)
g->dist[i][j] = inf;
for (int i = 0; i < edgenum; i++)
{
g->dist[from[i]][dest[i]] = weight[i];
}
} v
oid prim(graph1 *g,int start)
{
edge*T = (edge*)malloc((g->num - 1)*sizeof(edge));
int i = 0;
if (start > g->num - 1)
return;
int j = 0;
while (i <= g->num - 1)
{
if(i!=start)
{
T[j].from = start;
T[j].dest = i;
T[j].weight = g->dist[start][i];
j++;
} i+
+;
} f
or (int i = 0; i < g->num - 2; i++)
{
double min = inf;
int curnode = 0;
for (int j = i; j < g->num - 1; j++)
{
if (T[j].weight < min)
{
min = T[j].weight;
curnode = j;
}
} e
dge temp = T[curnode];
T[curnode] = T[i];
T[i] = temp;
curnode = T[i].dest;
for (int k = i + 1; k < g->num - 1; k++)
{
if (T[k].weight > g->dist[curnode][T[k].dest])
{
T[k].from = curnode;
T[k].weight = g->dist[curnode][T[k].dest];
}
}
} d
ouble tep = 0;
for (int i = 0; i < g->num - 1; i++)
{
printf("%d--%d ", T[i].from, T[i].dest);
tep += T[i].weight;
} p
rintf("weight=%f ", tep);
} v
oid kruskal(graph* g)
{
edge*T = (edge*)malloc(sizeof(edge)*g->edgenum);
int cur = 0;
int *group = (int*)malloc(sizeof(int)*g->num);
for (int i = 0; i < g->num; i++)
group[i] = i;
for (int i = 0; i < g->num; i++)
{
index*p = g->vex[i].link;
while (p != NULL)
{
int lock = 0;
for (int k = 0; k < cur; k++)
{
if (T[k].dest == p->aj&&T[k].from == i || T[k].from == p->aj&&T[k].dest == i)
{
lock = 1;
break;
}
}
if (lock == 0)
{
T[cur].from = i;
T[cur].dest = p->aj;
T[cur].weight = p->weight;
cur++;
} p
= p->next;
}
}
for (int i = cur; i > 0; i--)
for (int j = 0; j < i; j++)
{
if (T[j].weight > T[j + 1].weight)
{
double temp = T[j].weight;
T[j].weight = T[j + 1].weight;
T[j + 1].weight = temp;
}
}
int num = 0;
int j = 0;
int g1 = T[1].from;
while (num < g->num-1&&j<cur)
{
if (group[T[j].from] != group[T[j].dest])
{
for (int m = 0; m < cur;m++)
if(group[m]==group[T[j].dest])
group[m] = group[T[j].from];
printf("%d--%d ", T[j].from, T[j].dest);
} j+
+;
}
} v
oid dijkstra(int start, graph1*g)
{
int *generated = (int*)malloc(sizeof(int)*g->num);
double *dist = (double*)malloc(sizeof(double)*g->num);
int *pre = (int *)malloc(sizeof(int)*g->num);
for (int i = 0; i < g->num; i++)
{
generated[i] = 0;
if (g->dist[start][i] < inf)
pre[i] = start;
else
pre[i] = -1;
dist[i] = g->dist[start][i];
} d
ist[start] = 0;
for (int i = 0; i < g->num; i++)
{
double min = inf;
int temp = -1;
for (int j = 0; j < g->num; j++)
{
if (generated[j] == 0 && dist[j] <= min)
{
min = dist[j];
temp = j;
}
} g
enerated[temp] = 1;
for (int j = 0; j < g->num; j++)
{
if (!generated[j]&&dist[j]>dist[temp] + g->dist[temp][j])
{
dist[j] = dist[temp] + g->dist[temp][j];
pre[j] = temp;
}
}
} p
rintf("shortest path found!\n");
for (int j = 0; j < g->num; j++)
{
printf("from %d to %d dist=%f ,%d", start, j, dist[j],j);
int index = pre[j];
while (index != -1)
{
printf("<-%d", index);
index = pre[index];
} p
rintf("\n");
}
} v
oid floyd(graph1 *g)
{
int path[maxsize][maxsize];
double dist[maxsize][maxsize];
for (int i = 0; i < g ->num; i++)
for (int j = 0; j < g->num; j++)
{
dist[i][j] = g->dist[i][j];
if (dist[i][j] < inf)
path[i][j] = i;
else
path[i][j] = -1;
if (i == j)
dist[i][j] = 0;
}
for (int k = 0; k < g->num; k++)
for (int i = 0; i < g->num; i++)
for (int j = 0; j < g->num; j++)
{
if (dist[i][j]>dist[i][k] + dist[k][j])
{
dist[i][j] = dist[i][k] + dist[k][j];
path[i][j] = path[k][j];
}
}
for (int i = 0; i < g->num; i++)
for (int j = 0; j < g->num; j++)
{
if (dist[i][j] == inf)
{
printf("cannot from%dto%d\n",i,j);
continue;
} if
(i == j)
continue;
printf("from %d to %d dist is%f,%d", i, j, dist[i][j],j);
int index = path[i][j];
while (index != -1)
{
printf("<-%d", index);
index = path[i][index];
} p
rintf("\n");
}
} v
oid aov(graph*g)
{
int num = g->num;
int*out = (int*)malloc(sizeof(int)*g->num);
for (int i = 0; i < g->num; i++)
out[i] = 0;
while (num > 0)
{
for (int i = 0; i < g->num; i++)
{
if (out[i] == 0 && g->vex[i].in == 0)
{
printf("%d->", g->vex[i].data);
index*p = g->vex[i].link;
out[i] = 1;
num--;
while (p != NULL)
{
g->vex[p->aj].in--;
p = p->next;
}
}
}
}
} i
nt main()
{
datatype vexnode[] = { 0,1,2,3,4,5,6 };
int from[] = {0,1,0,2,3,3,4,5,2};
int dest[] = {1,4,2,3,4,5,6,6,5};
double weight[] = {2,5,3,6,8,4,3,7,9};
datatype vexnode1[] = { 0,1,2,3,4,5 };
int from1[] = {0,0,0,4,4,2,1};
int dest1[] = {2,4,5,5,3,3,2};
double weight1[] = {6,10,5,2,17,2,8};
graph *g;
create_graphd(g,vexnode1,from1,dest1,weight1,6,7);
aov(g);
getchar();
}