① 已知一个有向图的邻接表，试编写一个算法求每个结点的出度和入度。
因此要在多个邻接顶点之间约定一种访问次序。@由于图中可能存在回路，在访问某个顶点之后，可能沿着锋悔租某条路径银兆又回到图的深度优先搜索遍历算法p88
联通的无回路的无向图，简称树。树中的悬挂点又前蚂成为树叶，其他顶点称为分支点。
② 怎么用c语言画邻接表
1、先把要讲解的巧码图在下面展示一下，先看一下；
邻接表是图的常用储存结构之一。邻接表由表头结点和表结点两部分组成，其中图中每个顶点均对应一个存储在数组中的表头结点。
③ C语言数据结构图求入度的算法
//思路:先把邻接表芹坦拆转换成逆邻接表，这样问题简单多了。
//数组out，保存各节点的入度
void countindegree(AdjList gin, AdjList gout)
{
//设有向图有n个顶点，建逆邻接表的顶点向量。
for (int i=1;i<=n;i++)
{
gin[i].vertex=gout[i].vertex;
gin.firstarc=null;
}
//邻嫌枣接表转为逆邻接表。
for (i=1;i<=n;i++)
{
p=gout[i].firstarc;//取指向邻接表的指针。
while (p!=null)
{
j=p->adjvex;
s=(ArcNode *)malloc(sizeof(ArcNode));//申请结点空间。
s->adjvex=i;
s->next=gin[j].firstarc;
gin[j].firstarc=s;
p=p->next;//下一个邻接点。
}//while
}//endof for
//统计各节点的入度
for (i=0; i<n; i++)
{
p = gin[i].firstarc;
while(p ! = null)
{
out[i]++;
p = p->next;
} //信谈endof while
} //endof for
}//endof function
④ 求C# 邻接表 代码
我把租搜我过去课上老师发的C语言代码发给你吧，你在VS里也可以运行。
#include<iostream.h>
#include<stdlib.h>
#define error 0
#define ok 1
#define Overflow -2
#define Underflow -2
#define max_vertex_num 20
int visited[max_vertex_num];
struct qnode{
int qdata;
qnode *next;
};
struct queue{
qnode *front;
qnode *rear;
};
void initqueue(queue &Q){
Q.front=Q.rear=(qnode *)malloc(sizeof(qnode));
if(!Q.front)
exit(Overflow);
Q.front->next=NULL;
}
void enqueue(queue &Q,int e){
qnode *p=(qnode *)malloc(sizeof(qnode));
if(!p) exit(Overflow);
p->qdata=e; p->next=NULL;
Q.rear->next=p; Q.rear=p;
}
void dequeue(queue &Q,int &e){
if(Q.front==Q.rear) exit(Underflow);
qnode *p=Q.front->next;
e=p->qdata;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
}
int queueempty(queue Q){
if(Q.rear==Q.front) return ok;
else return error;
}
typedef int vertextype;
typedef int Status;
typedef struct arcnode{
int adjvex;
struct arcnode *next;
}arcnode,*arcptr;
typedef struct{
vertextype data;
arcnode *firstarc;
}vnode;
typedef struct{
vnode adjlist[max_vertex_num];
int vexnum,arcnum;
int kind;
}algraph;
int locate(algraph g,vertextype v){
int i=0;
while(i<g.vexnum){
if(v==g.adjlist[i].data) return i;
else i++;
}
return -1;
}
Status create_dg(algraph &g){
vertextype v1,v2;
arcnode *p;
g.kind=0;
cin>>g.vexnum>>g.arcnum;
for(int i=0;i<g.vexnum;i++){
cin>>g.adjlist[i].data;
g.adjlist[i].firstarc=NULL;
}
for(int k=1;k<g.vexnum;k++){
cin>>v1>>v2;
int i=locate(g,v1);
int j=locate(g,v2);
if(i<0||j<0) return error;
p=(arcnode*)malloc(sizeof(arcnode));
p->adjvex=j;
p->next=g.adjlist[i].firstarc;
g.adjlist[i].firstarc=p;
}
return ok;
}
void dfs(algraph g,int v){
arcptr p;
visited[v]=1;
cout<<v<<g.adjlist[v].data<橘型早<' ';
p=g.adjlist[v].firstarc;
while(p){
if(visited[p->圆雀adjvex]==0) dfs(g,p->adjvex);
p=p->next;
}
}
void dfstraverse(algraph g){
for(int i=0;i<g.vexnum;i++)
visited[i]=0;
for(i=0;i<g.vexnum;i++)
if(visited[i]==0) dfs(g,i);
}
int firstadj(algraph g,vertextype v){//求第一邻接顶点
int i=locate(g,v);
if(i<0) return -2;
int j=0;
if(g.adjlist[i].firstarc)
return g.adjlist[i].firstarc->adjvex;
else
return -1;
}
int nextadj(algraph g,vertextype v,vertextype w){ //求第一邻接顶点的下个邻接点
int i=locate(g,v), j=locate(g,w);
if(i<0||j<0) return -2;
j=0;
if(g.adjlist[i].firstarc)
return g.adjlist[i].firstarc->adjvex;
else
return -1;
}
void bfs(algraph g){
for(int i=0;i<g.vexnum;i++)
visited[i]=0;
queue q;
initqueue(q);
for(i=0;i<g.vexnum;i++){
if(visited[i]==0){
visited[i]=1;int v,w;
cout<<i;
enqueue(q,i);
while(!queueempty(q)){
dequeue(q,v);
for(w=firstadj(g,v);w>=0;w=nextadj(g,v,w))
if(visited[w]==0){
visited[w]=1;
cout<<w;
enqueue(q,w);
}
}
}
}
}
void main(){
algraph g;
create_dg(g);
bfs(g);
}
⑤ c语言，关于邻接表的建立
AdjList 是自定义类型，是char类型，
第二行 typedef将char类型自定义为 VertexType，即VertexType代表了char型，
VertexType a 就相当于 char a；
同理
倒数第五行 typedef将VertexNode自定义为 AdjList[MaxVertexNum]类型，也就是说现在AdjList就代表了一个 “结构体数组” 类型
AdjList adjlist 相当于 VertexNode adjlist[MaxVertexNum]
这里主要是typedef关键字的使用 希望能帮到你
⑥ 数据结构-图的邻接表表示（C语言）
//grap_theory.cpp:定义控制台应用程序的入口点。
//
//#include"stdafx.h"//VS2010头文件
#include<stdio.h>
#defineNTOTAL(26*4)//最大路径数目
#defineMAX_DISTANCE10000.0
structpiont{
intline_adjacency_list;
intnum_piont;
inttest_num[2];
charfrom[NTOTAL];
charto[NTOTAL];
charall_piont[NTOTAL];
intall_piont_num[NTOTAL];
floatdistance[NTOTAL];
floatdistance_all[NTOTAL][NTOTAL];
};//结构体定义
voidread(piont*test){
inti;
chartemp[100];
scanf("%d",&test->line_adjacency_list);//读取行数
gets(temp);//读取回车字符
for(i=0;i<test->line_adjacency_list;i++){//读取列表
scanf("%c%c%f",&test->from[i],&test->to[i],&test->distance[i]);
gets(temp);//读取回车字符
}
scanf("%c%c",&test->from[i],&test->to[i]);//读取短短路径名称
}
voidcal_num_piont(piont*test){
inti,j;
intfrom_num,to_num;
test->num_piont=0;
for(i=0;i<NTOTAL;i++){
test->all_piont_num[i]=0;//点的度数清零
test->distance_all[i][i]=0.0;
for(j=i+1;j<NTOTAL;j++){
test->distance_all[i][j]=MAX_DISTANCE;
test->distance_all[j][i]=MAX_DISTANCE;
}
}
for(i=0;i<test->line_adjacency_list;i++){
//判断from
for(j=0;j<test->num_piont;j++){
if(test->from[i]==test->all_piont[j]){
from_num=j;
test->all_piont_num[j]++;
break;
}
}
if(j==test->num_piont){
test->all_piont[j]=test->from[i];
from_num=j;
test->all_piont_num[j]++;
test->num_piont++;
}
//判断end
for(j=0;j<test->num_piont;j++){
if(test->to[i]==test->all_piont[j]){
to_num=j;
test->all_piont_num[j]++;
break;
}
}
if(j==test->num_piont){
test->all_piont[j]=test->to[i];
to_num=j;
test->all_piont_num[j]++;
test->num_piont++;
}
test->distance_all[from_num][to_num]=test->distance[i];
test->distance_all[to_num][from_num]=test->distance[i];
}
//判断所求点的位置
for(i=0;i<test->num_piont;i++){
if(test->from[test->line_adjacency_list]==test->all_piont[i])
test->test_num[0]=i;
if(test->to[test->line_adjacency_list]==test->all_piont[i])
test->test_num[1]=i;
}
}
floatmin_distance(piont*test){
inti,j,k,n;
floatmin_dis;
floatdis_i_k_add_k_j;
n=test->num_piont;
//Floyd-Warshall算法
for(k=0;k<n;k++){
for(i=0;i<n;i++){
for(j=0;j<n;j++){
dis_i_k_add_k_j=(test->distance_all[i][k]+test->distance_all[k][j]);
if(test->distance_all[i][j]>dis_i_k_add_k_j)
test->distance_all[i][j]=dis_i_k_add_k_j;
}
}
}
min_dis=test->distance_all[test->test_num[0]][test->test_num[1]];
returnmin_dis;
}
voidtest_printf(piont*test,floatmin_dis){
inti;
printf("%d ",test->num_piont);
for(i=0;i<test->num_piont;i++){
printf("%d ",test->all_piont_num[i]);
}
printf("%-8.0f ",min_dis);
}
voidmain()
{
floatmin_dis;
pionttest1;//结构体声明
read(&test1);
cal_num_piont(&test1);
min_dis=min_distance(&test1);
test_printf(&test1,min_dis);
}
⑦ 建立一个有向邻接表，计算他的初度和入度
深度优先是从某个顶点出发，访问完后，寻找一个未访问的邻接顶点继续深度优先，如果此路不同就往回退，所以看邻接表，首先访问V1，完了后顺链寻找没有访问的邻接顶点，自然链表中的第一个结点就侍穗罩是v3，接着转到v3再族升来深度优先，访问v3后，在其链表中第一个邻接顶点是v4 接着访问v4，下面走不通，回到v3，继续顺链往后，自然老闹是v5，v5的邻接顶点中v2还没有访问 所以序列为v1, v3, v4, v5, v2 再看广度优先，从某个顶点完成后，需要一口气将其邻接未访问的所有顶点都访问，后面类推 于是过程是先v1，再顺链将v3，v2依次访问完，然后再依次访问v3和v2的各个未访问邻接顶点，v3链表中顺链可以访问v4，v5，所以最后访问序列为v1, v3, v2, v4, v5
⑧ 请教变成数据结构大神题目。 算法设计:以邻接表为储存结构，编写一个算法求有向图中每个顶点的入度。
邻接表还是逆邻接表？如果是逆邻接表，每个顶点出发邻接表的链表中的结点个数就是入度
如果是邻接表过程如下：
有一个辅慧备助数组，大小就是顶点数量，所有元素初值都为0
从头到尾遍历每个顶点出发的邻接表的结点闹碧缓，只要当前结点的数据是几（也就是第液模几个结点被有向弧进入了），这个下标的辅助数组元素加1，等所有的邻接表的小链表遍历完了，这个辅助数组中各个下标的数字就是该顶点的入度
⑨ 编写算法，求有向图中各定点的入度
先是根据邻接表的顶点个数n,创建一个int型的数组a[n]（用来存储各顶点的入度）,把a[n]中的每一项置为0。然后再邻接表埋扮睁遍历一下就行了，先是顶点遍历，缺祥然后弧遍历。
我大致写一下算法。
#define n 30;
struct diagraph
{
struct vertex * head;
struct Vertex ver;
struct Edge edg;
}
struct Vertex
{
int pos;
Vertex * nextVertex;
Edge * firstEdge;
};
struct Edge
{
int pos;
Edge * nextEdge;
Vertex * endPoint;//弧尾指弯岁向结点的指针
}
void main()
{
struct digraph a;
//先是邻接表的建立，我就不写了，建立完之后如下
int a[n];
int i,j;
struct Vertex * current = a.head;
struct Edge * eCurrent;
for(i=0;i<n;i++)
{
eCurrent=current->firstEdge;
while(eCurrent!=0)
{
a[eCurrent->pos]++;
eCurrent=eCurrent->nextEdge;
}
current = current->nextVertex;
}
}
我直接在知道上面写的，只是个大概，能看懂的话就给个分吧
⑩ c语言 数据结构基本功能要求：
#include "stdio.h"
#define MAX 50
typedef struct LNode{
int data;
struct LNode *next;
}LNode;
void OutputDegree(int matrix[MAX][MAX], int n);
void Insert(LNode *head, int data);
void list(LNode *head);
void createAdjList(int matrix[MAX][MAX], int n, LNode *head[]);
void main()
{
int matrix1[MAX][MAX] = {{0,1,1},{1,0,1},{0,0,0}};
int matrix2[MAX][MAX] = {{0,1,0,1,0},{1,0,1,0,0},{0,1,0,1,1},{1,0,1,0,0},{0,0,1,0,0}};
int n; /* 顶点数 */
LNode *head[MAX];
int i;
n = 3;
printf("List degree of all vertex : \n");
OutputDegree(matrix1, n);
for(i=0; i<n; i++)
{
head[i] = (LNode *)malloc(sizeof(LNode));
head[i]->data = i+1;
}
createAdjList(matrix1, n, head);
printf("Adjancency List : \n");
for(i=0; i<n; i++)
{
printf("%d : ", head[i]->data);
list(head[i]);
printf("\n");
}
n = 5;
printf("List degree of all vertex : \n");
OutputDegree(matrix2, n);
for(i=0; i<n; i++)
{
head[i] = (LNode *)malloc(sizeof(LNode));
head[i]->data = i+1;
}
createAdjList(matrix2, n, head);
printf("Adjancency List : \n");
for(i=0; i<n; i++)
{
printf("%d : ", head[i]->data);
list(head[i]);
printf("\n");
}
}
/* 输出顶点的度 */
void OutputDegree(int matrix[MAX][MAX], int n)
{
int InDegree[MAX]; /* 入度 */
int OutDegree[MAX]; /* 出度 */
int i, j;
for(i=0; i<n; i++)
{
InDegree[i] = OutDegree[i] = 0;
for(j=0; j<n; j++)
{
InDegree[i] += matrix[j][i];
OutDegree[i] += matrix[i][j];
}
}
for(i=0; i<n; i++)
{
printf("vertex %d : In - %d, Out - %d\n", i+1, InDegree[i], OutDegree[i]);
}
}
void Insert(LNode *head, int data)
{
LNode *pre = head->next;
LNode *temp;
temp = (LNode*)malloc(sizeof(LNode));
temp->data = data;
temp->next = NULL;
if(pre == NULL)
{
head->next = temp;
return;
}
for(; pre->next!=NULL; pre=pre->next);
pre->next = temp;
}
void list(LNode *head)
{
LNode *curr;
for(curr=head->next; curr!=NULL; curr=curr->next)
{
printf("%d\t", curr->data);
}
}
/* 根据邻接矩阵构建邻接表 */
void createAdjList(int matrix[MAX][MAX], int n, LNode *head[])
{
int i, j;
for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
{
if(matrix[i][j] != 0)
Insert(head[i], j+1);
}
}
}