拓扑化编程
typedef struct node
{
int adjvex;
struct node *next;
}edgenode;
typedef struct
{
int vertex;
int id;
edgenode *link;
}vexnode;
vexnode dig[n];
void topsort(vexnode dig[])
{
int i,j,k,m=0,top=-1;
edgenode *p;
for(i=0;i<n;i++)
if(dig[i].id==0)
{
dig[i].id=top;
top=i;
}
while(top!=-1)
{
j=top;
top=dig[top].id;
cout<<dig[j].vertex+1<<"\t";
m++;
p=dig[j].link;
while(p)
{
k=p->adjvex;
dig[k].id--;
if(dig[k].id==0)
{
dig[k].id=top;
top=k;
}
p=p->next;
}
}
if(m<n)
cout<<"The network has a cycle.."<<endl;
}
这个是用栈实现的一个算法，你看下吧
❷ 拓扑排序 编程
*/
#include <stdio.h>
#include <malloc.h>
// 输出有向图的一个拓扑序列。实现算法7.12的程序
// 图的邻接表存储表示
#define MAX_NAME 3 // 顶点字符串的最大长度+1
#define MAX_VERTEX_NUM 20
typedef int InfoType; // 存放网的权值
typedef char VertexType[MAX_NAME]; // 字符串类型
typedef enum{DG,DN,AG,AN}GraphKind; // {有向图,有向网,无向图,无向网}
typedef struct ArcNode
{
int adjvex; // 该弧所指向的顶点的位置
struct ArcNode *nextarc; // 指向下一条弧的指针
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;
// 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1。
int LocateVex(ALGraph G,VertexType u)
{
int i;
for(i=0;i<G.vexnum;++i)
if(strcmp(u,G.vertices[i].data)==0)
return i;
return -1;
}
// 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图)。
int CreateGraph(ALGraph *G)
{
int i,j,k;
int w; // 权值
VertexType va,vb;
ArcNode *p;
printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
scanf("%d",&(*G).kind);
printf("请输入图的顶点数和边数:（空格）\n");
scanf("%d%d", &(*G).vexnum, &(*G).arcnum);
printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);
for(i = 0; i < (*G).vexnum; ++i) // 构造顶点向量
{
scanf("%s", (*G).vertices[i].data);
(*G).vertices[i].firstarc = NULL;
}
if((*G).kind == 1 || (*G).kind == 3) // 网
printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
else // 图
printf("请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
for(k = 0;k < (*G).arcnum; ++k) // 构造表结点链表
{
if((*G).kind==1||(*G).kind==3) // 网
scanf("%d%s%s",&w,va,vb);
else // 图
scanf("%s%s",va,vb);
i = LocateVex(*G,va); // 弧尾
j = LocateVex(*G,vb); // 弧头
p = (ArcNode*)malloc(sizeof(ArcNode));
p->adjvex = j;
if((*G).kind == 1 || (*G).kind == 3) // 网
{
p->info = (int *)malloc(sizeof(int));
*(p->info) = w;
}
else
p->info = NULL; // 图
p->nextarc = (*G).vertices[i].firstarc; // 插在表头
(*G).vertices[i].firstarc = p;
if((*G).kind >= 2) // 无向图或网,产生第二个表结点
{
p = (ArcNode*)malloc(sizeof(ArcNode));
p->adjvex = i;
if((*G).kind == 3) // 无向网
{
p->info = (int*)malloc(sizeof(int));
*(p->info) = w;
}
else
p->info = NULL; // 无向图
p->nextarc = (*G).vertices[j].firstarc; // 插在表头
(*G).vertices[j].firstarc = p;
}
}
return 1;
}
// 输出图的邻接表G。
void Display(ALGraph G)
{
int i;
ArcNode *p;
switch(G.kind)
{
case DG: printf("有向图\n");
break;
case DN: printf("有向网\n");
break;
case AG: printf("无向图\n");
break;
case AN: printf("无向网\n");
}
printf("%d个顶点：\n",G.vexnum);
for(i = 0; i < G.vexnum; ++i)
printf("%s ",G.vertices[i].data);
printf("\n%d条弧(边):\n", G.arcnum);
for(i = 0; i < G.vexnum; i++)
{
p = G.vertices[i].firstarc;
while(p)
{
if(G.kind <= 1) // 有向
{
printf("%s→%s ",G.vertices[i].data,
G.vertices[p->adjvex].data);
if(G.kind == DN) // 网
printf(":%d ", *(p->info));
}
else // 无向(避免输出两次)
{
if(i < p->adjvex)
{
printf("%s－%s ",G.vertices[i].data,
G.vertices[p->adjvex].data);
if(G.kind == AN) // 网
printf(":%d ",*(p->info));
}
}
p=p->nextarc;
}
printf("\n");
}
}
// 求顶点的入度，算法7.12、7.13调用
void FindInDegree(ALGraph G,int indegree[])
{
int i;
ArcNode *p;
for(i=0;i<G.vexnum;i++)
indegree[i]=0; // 赋初值
for(i=0;i<G.vexnum;i++)
{
p=G.vertices[i].firstarc;
while(p)
{
indegree[p->adjvex]++;
p=p->nextarc;
}
}
}
typedef int SElemType; // 栈类型
#define STACK_INIT_SIZE 10 // 存储空间初始分配量
#define STACKINCREMENT 2 // 存储空间分配增量
// 栈的顺序存储表示 P46
typedef struct SqStack
{
SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
SElemType *top; // 栈顶指针
int stacksize; // 当前已分配的存储空间，以元素为单位
}SqStack; // 顺序栈
// 构造一个空栈S。
int InitStack(SqStack *S)
{
// 为栈底分配一个指定大小的存储空间
(*S).base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if( !(*S).base )
exit(0); // 存储分配失败
(*S).top = (*S).base; // 栈底与栈顶相同表示一个空栈
(*S).stacksize = STACK_INIT_SIZE;
return 1;
}
// 若栈S为空栈（栈顶与栈底相同的），则返回1，否则返回0。
int StackEmpty(SqStack S)
{
if(S.top == S.base)
return 1;
else
return 0;
}
// 插入元素e为新的栈顶元素。
int Push(SqStack *S, SElemType e)
{
if((*S).top - (*S).base >= (*S).stacksize) // 栈满，追加存储空间
{
(*S).base = (SElemType *)realloc((*S).base,
((*S).stacksize + STACKINCREMENT) * sizeof(SElemType));
if( !(*S).base )
exit(0); // 存储分配失败
(*S).top = (*S).base+(*S).stacksize;
(*S).stacksize += STACKINCREMENT;
}
*((*S).top)++=e;
// 这个等式的++ * 优先级相同，但是它们的运算方式，是自右向左
return 1;
}
// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回1；否则返回0。
int Pop(SqStack *S,SElemType *e)
{
if((*S).top == (*S).base)
return 0;
*e = *--(*S).top;
// 这个等式的++ * 优先级相同，但是它们的运算方式，是自右向左
return 1;
}
// 算法7.12 P182
// 有向图G采用邻接表存储结构。若G无回路,则输出G的顶点的一个拓扑序
// 列并返回1, 否则返回0。
int TopologicalSort(ALGraph G)
{
int i,k,count,indegree[MAX_VERTEX_NUM];
SqStack S;
ArcNode *p;
FindInDegree(G,indegree); // 对各顶点求入度indegree[0..vernum-1]
InitStack(&S); // 初始化栈
for(i=0;i<G.vexnum;++i) // 建零入度顶点栈S
if(!indegree[i])
Push(&S,i); // 入度为0者进栈
count=0; // 对输出顶点计数
while(!StackEmpty(S))
{
// 栈不空
Pop(&S,&i);
printf("%s ",G.vertices[i].data); // 输出i号顶点并计数
++count;
for(p=G.vertices[i].firstarc;p;p=p->nextarc)
{
// 对i号顶点的每个邻接点的入度减1
k=p->adjvex;
if(!(--indegree[k])) // 若入度减为0,则入栈
Push(&S,k);
}
}
if(count<G.vexnum)
{
printf("此有向图有回路\n");
return 0;
}
else
{
printf("为一个拓扑序列。\n");
return 1;
}
}
int main()
{
ALGraph f;
printf("请选择有向图\n");
CreateGraph(&f);
Display(f);
TopologicalSort(f);
system("pause");
return 0;
}
/*
输出效果：
请选择有向图
请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): 0
请输入图的顶点数和边数:（空格）
4 4
请输入4个顶点的值(<3个字符):
a
b
c
d
请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):
a b
a c
b d
c d
有向图
4个顶点：
a b c d
4条弧(边):
a→c a→b
b→d
c→d
a b c d 为一个拓扑序列。
请按任意键继续. . .
*/
❸ c语言 Socket编程，如何定义网络拓扑结构和路由表
原理是 Telnet 路由器IP,进入路由器,然后再进入特权用户模式,敲命令show cdp neighbor detail,可以查看与之相连的,同理,查出后再进去查另一台跟它相连的 整个拓扑图就出来了
❹ 怎样通过编程实现拓扑排序
实现的基本方法
拓扑排序方法如下:
(1)从有向图中选择一个没有前驱(即入度为0)的顶点并且输出它.
(2)从网中删去该顶点,并且删去从该顶点发出的全部有向边.
(3)重复上述两步,直到剩余的网中不再存在没有前驱的顶点为止.
拓扑序列
C++核心代码
bool
TopologicalSort(int
a[][101])
//可以完成拓扑排序则返回True
{
int
n
=
a[0][0],
i,
j;
int
into[101],
ans[101];
memset(into,
0,
sizeof(into));
memset(ans,
0,
sizeof(ans));
for
(i
=
1;
i
<=
n;
i++)
{
for
(j
=
1;
j
<=
n;
j++)
{
if
(a[i][j]
>
0)
into[j]++;
}
}
into[0]
=
1;
for
(i
=
1;
i
<=
n;
i++)
{
j
=
0;
while
(into[j]
!=
0)
{
j++;
if
(j
>
n)
return
false;
}
ans[i]
=
j;
into[j]
=
-1;
for
(int
k
=
1;
k
<=
n;
k++)
{
if
(a[j][k]
>
0)
into[k]--;
}
}
for
(i
=
1;
i
<=
n;
i++)
{
cout
<<
ans[i]
<<
"
";
}
cout
<<
endl;
return
true;
}
❺ 拓扑关系怎样在编程中表示
要选择数据结构哦，
用树或者图储存，各个点的坐标就可以，参考书上有例子的
❻ 数据结构编程题目(使用拓扑排序编写）
这个题目应该用图的深度优先搜索来实现
❼ c语言编程 拓扑算法
i=0
A[1...n]为一个新数组
循环
寻找入度为零的点，将该点放到位置A[i]中
i=i+1
将该点出边删除
输出A
❽ 利用拓扑排序,编程实现一个偏序关系的全序关系
拓扑排序的代码
http://blog.csdn.net/peerslee/article/details/50058245
不懂可以留言哈，希望采纳阿
❾ c# 画拓扑图
自己定义工具栏就好了。
方法一：粗俗画法，先PS直接把图片背景抽掉，然后放在自定义控件作为背景，然后imagelayout属性给成布满就好了，这样他就一个图片控件。
方法二：精细做法，选中你的工具栏按钮，GDI+画图，在panel里面用e.Graphic画图，计算坐标，其实也不是很难，只要你熟悉Drawing类，至少比C++、Android方法简单多了。简单演示一下原理：
//方法一按钮画图事件，当按下去鼠标形状改变成画笔，Mousedown后创建新控件：
privatevoidbuttonC_Click(Objectsender,MouseEvente)
{
//选中颜色变化
buttonC.backColor=color...;
}
privatevoidpanel1_MouseDown(Objectsender,MouseEvente)
{
//如果控件编辑状态颜色变化，那么就可以编辑
if(buttonC.BackColor=Color....)
{
UserControl1us=newUserControl1();
us.Width=...;
us.Height=...;
//...
us.Left=...;
us.Top=...;
panel1.Controls.Add(us);
//完成后颜色恢复
buttonC.BackColor=Color.White;
}
}
方法二：
//一样的道理，不过他不是创建控件，而是画图
publicintx1,x2,y1,y2;
privatevoidpanel1_MouseDown(Objectsender,MouseEvente)
{
if(buttonC.backColor==Color...)
{
x1=e.X;
y1=e.Y;
}
}
privatevoidpanel1_MouseUp(Objectsender,MouseEvente)
{
if(buttonC.backColor==Color...)
{
x2=e.X;
y2=e.Y;
//当鼠标弹起，结束画线
Graphicsg=e.Graphics;
g.DrawLine(Pens.Blue,newPoint(x1,y1),newPoint(x2,y2));
buttonC.backColor=Color.White;//恢复初始状态
}
}
//这里还要写改变线条坐标事件，方便你去改动
//其他的图形也可以这么画，是不是没你想的复杂？
❿ c++ 编程 拓扑结构
网状结构最简单的可以使用二维数组实现。比如：
int g[5][5];可以表示一个有5个节点的图。其中，g[i][j]可以表示节点i和节点j之间的距离（或者从i到j的费用，节点i到j之间断路的概率，等等）