代码注释格式（合集）

时间：2019-05-14 17:20:18下载本文作者：会员上传
简介：写写帮文库小编为你整理了多篇相关的《代码注释格式》，但愿对你工作学习有帮助，当然你在写写帮文库还可以找到更多《代码注释格式》。

第一篇：代码注释格式

////////////////////////////////////////////////////////////////////////// //函数名称: WriteFile //函数功能: 向加密锁创建文件,并且向文件中写入数据,注意写入的数据不宜过大,最好少于2k为最佳 //参数说明: fileSize: 文件的大小,以字节为单位 // fileID: 文件在加密锁中的ID, // fileName: 文件在加密锁中的名字 // fileContent: 文件内容

//返 回 值: 如果写入文件成功,则返回true,如果写入文件失败,则返回false.//作 者: luyao ///////////////////////////////////////////////////////////////

第二篇：JAVA代码注释规范

JAVA代码注释规范

一、规范存在的意义

1.好的注释规范可以让人一眼看明白这是干什么的，特别是对于我们这种行业；共同合作完成一个项目需要分工明确，所以也需要有明了的注释规范。

2.正确的应用注释规范可以增加代码的可读性、理解性。3.好的代码规范可以提高团队的开发效率，从而节省时间。4.长期的坚持代码规范可以让程序员养成一个良好的习惯，甚至锻炼出思维。

二、命名规范

1.一般概念

1)尽量使用完整的英文描述。2)采用相对好理解的术语。

3)采用骆驼命名的规范使名字增加可读性。4)尽量少用缩写提高可读性。5)避免名字过长。

6)避免使用类似的名字。7)避免使用特殊符号。2.主要的运用

1)类（class）的命名

2)接口(interface)的命名 +方法(method)的命名 3)参数(param)的命名

三、注释规范

1.一般概念

1)注释应该增加代码的清晰度 2)保持代码的整洁

3)在写代码之前或同时注意写上注释

4)注释出为什么做这件事，做这件事的结果 2.注释那些部分

1)java文件：版权信息、创建时间、创建人 2)类：目的、所完成功能、版权信息、创建人 3)方法：参数含义、返回值 4)属性：字段描述

5)接口：目的、创建人、版本号、创建时间

四、代码格式规范

1.单行注释://注释内容，一般与代码后空4-8格，注释必须对齐 2.块状注释：/*注释内容*/，一般是注释从以/*开始，以*/结束中的所有内容。3.文档注释：/**......*/所以注释文 档必须书写在类、域、构造函数、方法，以及字段(field)定义之前.注释文档由两部分组成——描述、块标记。4.javadoc注释标签

@author 对类的说明 标明开发该类模块的作者

@version 对类的说明 标明该类模块的版本

@see 对类、属性、方法的说明 参考转向，也就是相关主题

@param 对方法的说明 对方法中某参数的说明

@return 对方法的说明 对方法返回值的说明

@exception 对方法的说明 对方法可能抛出的异常进行说明

五、java注释具体实现

1.源文件注释

/** *文件名 *创建人 *创建时间 *修改人 *描述 *版本号 */ 2.类注释

/** *对此类的描述信息 *创建人 *版本号 *创建时间 */ 3.方法的注释

/** *方法的用处 *该方法的参数列 *该方法返回的值 */ 4.属性的注释

/** *字段的描述 */ 5.接口注释

/** *对此接口的描述 *创建人 *创建时间 *版本号 */ 6.构造方法注释

/** *描述该构造方法的用处 *该构造方法的参数列 *参数的类型 */

六、Jsp代码格式规范

1.多行注释:,一般是注释从以结束中的所有内容。

2.文本注释:<%--内容--%>,主要是对该页面的一些描述，目的、创建人、创建时间、版本号、文件名、备注、修改人等.例如: <%---创建人-创建时间-版本号-文件名-备注-修改人--%> 3.伪劣标签注释:<% java语句块 %> 例如： <% JAVA代码块 %> 4.单行注释：//注释内容，一般与代码后空4-8格，注释必须对齐

七、JS代码格式规范

1.文本注释:/** 注释内容 **/，主要是对该页面的一些描述，目的、创建人、创建时间、版本号、文件名、备注、修改人等.也可以用于注释代码块。例如: /** *创建人 *创建时间 *版本号 *文件名 *备注 *修改人 **/

2.文本注释:/** 内容 */ ,主要是对该页面的一些描述，目的、创建人、创建时间、版本号、文件名、备注、修改人等.也可以用于注释代码块。例如: /** *创建人 *创建时间 *版本号 *文件名 *备注 *修改人 */ 3.单行注释: //注释内容，一般与代码后空4-8格，注释必须对齐 4.多行注释: /* 注释内容 */,一般是注释从以/* 开始，以*/结束中的所有内容。

八、JS注释具体实现 1.文件注释

/** *对此文件的描述信息 *创建人 *版本号 *创建时间 */ 2.方法的注释

/** *方法的用处 *该方法的参数列 *该方法返回的值 */ 3.模块的注释

/** *模块名称

*模块的用处

*/

第三篇：数据结构课设(完整代码可直接运行)附注释

#include #include #include #define

ERROR

0//定义字符常量error #define

OK

1//定义字符常量OK #define INFINITY

INT_MAX//INT_MAX是系统库中定义的无穷大常量，即2个字节所能表示的最大数

#define MAX_VERTEX_NUM

21//定义图、网的最大定点数为21 #define STACK_INIT_SIZE

100//定义栈的容量

#define STACKINCREAMENT

10//定义栈的每次增长量 #define MAX_INT 10000 //无穷大 typedef int AdjType;typedef struct{ int pi[MAX_VERTEX_NUM];//存放v到vi的一条最短路径 int end;}PathType;typedef char VType;//设顶点为字符类型

typedef enum{DG,UDG,DN,UDN}GraphKind;//定义图、网的枚举常量

/*················· 邻接矩阵····················*/ typedef struct ArcCell {

int

adj;

//弧的权值

//infotype

*info;}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{

char vexs[MAX_VERTEX_NUM];//存储顶点的数组

AdjMatrix arcs;//存储邻接矩阵的二维数组

int

vexnum,arcnum;//顶点数和弧数

GraphKind kind;//链接矩阵的类型

}MGraph;

/*················· 邻接表····················*/ typedef struct ArcNode{

int

adjvex;//与首节点关联的顶点

int

quan;//该顶点的权值

struct ArcNode

*nextarc;//指向下一个节点的指针

}ArcNode,*AList;typedef struct VNode {

char

data;//链表的各顶点

AList

firstarc;//链表的首节点 }VNode,AdjList[MAX_VERTEX_NUM];typedef struct{

AdjList

vertices;//存储链接表的各顶点

int

vexnum,arcnum;//顶点书和弧数

GraphKind

kind;//链接表的类型 }ALGraph;

/*················· 队列····················*/ typedef struct QNode{ char

data;//队列中元素数据

struct QNode

*next;//指向下一元素的指针 }QNode,*QueuePre;typedef struct{ QueuePre

front;//队首指针

QueuePre

rear;//队尾指针 }LinkQueue;

/*················· 栈····················*/ typedef struct { int

*base;//栈底指针

int

*top;//栈首指针

int

stacksize;//栈的大小 }SqStack;

/*················· 求最小生成树中的辅助数组··········*/ typedef struct { char

adjvex;//最小生成树的节点

int

lowcost;//到该节点的最小权值开销 }closedges[MAX_VERTEX_NUM];

int option;

//图的类型标识符 int visited[MAX_VERTEX_NUM];

//顶点访问标记数组 int indegree[MAX_VERTEX_NUM];//顶点入度记录数组 int ve[MAX_VERTEX_NUM];

//顶点权值记录数组

/*················· 链接矩阵类型设置··········*/ int SetGraphKind(MGraph &G,int option){

switch(option){

case 1: G.kind=DG;break;

case 2: G.kind=UDG;break;

case 3: G.kind=DN;break;

case 4: G.kind=UDN;break;

default: return ERROR;

}

return OK;}

/*················· 邻接表类型设置··········*/ int SetGraphKind(ALGraph &G,int option){

switch(option){

case 1: G.kind=DG;break;

case 2: G.kind=UDG;break;

case 3: G.kind=DN;break;

case 4: G.kind=UDN;break;

default: return ERROR;

}

return OK;}

/*················· 邻接矩阵顶点定位 ·················将顶点V代入，查询顶点存储数组，返回其数组下标 ··········*/ int LocateVex(MGraph G,char v){

int m;

for(m=1;m<=G.vexnum;m++){

if(G.vexs[m]==v)return m;

}

printf(“您输入的顶点不存在”);

return ERROR;}

/*················· 邻接表顶点定位 ·················将顶点V代入，查询顶点存储数组，返回其数组下标 ··········*/ int LocateVex(ALGraph G,char v){

int m;

for(m=1;m<=G.vexnum;m++){

if(G.vertices[m].data==v)return m;

}

printf(“您输入的顶点不存在”);

return ERROR;

}

/*················· 队列创建··········*/ int InitQueue(LinkQueue &Q){ Q.front=Q.rear=(QueuePre)malloc(sizeof(QNode));//申请存储空间，队首队尾指向同一位置

if(!Q.front)return ERROR;Q.front->next=NULL;return OK;}

/*················· 元素入队··········*/ int EnQueue(LinkQueue &Q,int e){ QueuePre p;p=(QueuePre)malloc(sizeof(QNode));if(!p)return OK;p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}

/*················· 元素出队··········*/ int DeQueue(LinkQueue &Q,int &e){ QueuePre p;if(Q.front==Q.rear)return ERROR;p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return OK;}

/*················· 判断队列是否为空··········*/ int QueueEmpty(LinkQueue Q){ if(Q.front==Q.rear)

return OK;return ERROR;}

/*················· 栈的创建··········*/ int InitStack(SqStack &S){ S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(int));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}

/*················· //元素入栈··········*/ int Push(SqStack &S,int e){ if(S.top-S.base>=S.stacksize){

S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREAMENT)*sizeof(int));

if(!S.base)return ERROR;

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREAMENT;} *S.top++=e;return OK;}

/*················· 元素出栈··········*/ int Pop(SqStack &S,int &e){ if(S.top==S.base)return ERROR;

e=*--S.top;return OK;}

/*················· 判断栈是否为空··········*/ int StackEmpty(SqStack S){ if(S.top==S.base)return OK;return ERROR;}

/*················· 创建邻接矩阵··········*/ int CreatGraph(MGraph &G){

int i,j,k,w;char x,y;

if(!SetGraphKind(G,option)){printf(“对图类型的设置失败”);return ERROR;}//设置链接矩阵类型

printf(“邻接矩阵：请输入定点的个数、弧的个数：”);

scanf(“%d %d”,&G.vexnum,&G.arcnum);

if(G.vexnum>20){

printf(“您输入的顶点个数超过最大值”);

return ERROR;

}//if

printf(“请输入%d个顶点n”,G.vexnum);

for(i=1;i<=G.vexnum;++i){//输入矩阵的各顶点

fflush(stdin);//清除缓存，略过

scanf(“%c”,&G.vexs[i]);

}//for

if(G.kind==DG||G.kind==UDG){//1.有向图和无向图的矩阵创建

for(i=1;i<=G.vexnum;i++)//矩阵初始化

for(j=1;j<=G.vexnum;j++)

G.arcs[i][j].adj=0;

if(G.kind==DG){//2.有向图

printf(“请输入有向图的两个相邻的顶点（如果互相邻接则也要输入）：n”);

for(k=1;k<=G.arcnum;k++){//循环输入

fflush(stdin);

scanf(“%c%c”,&x,&y);//输入矩阵中弧关联的两顶点

i=LocateVex(G,x);j=LocateVex(G,y);//将两顶点转换成顶点存储数组的下标

G.arcs[i][j].adj=1;

}//for

}//2.if

else{//2.无向图

printf(“请输入无向图的两个相邻的顶点（x,y）：n”);

for(k=1;k<=G.arcnum;k++){fflush(stdin);

scanf(“%c%c”,&x,&y);

i=LocateVex(G,x);j=LocateVex(G,y);

G.arcs[i][j].adj=1;G.arcs[j][i].adj=G.arcs[i][j].adj;//反向关联两顶点

}//for

}//2.else

}//1.if

else{//1.有向网和无向网

for(i=1;i<=G.vexnum;i++)

for(j=1;j<=G.vexnum;j++)

G.arcs[i][j].adj=INT_MAX;//矩阵初始化

if(G.kind==DN){ //3.有向网

printf(“请输入有向网的两个相邻的顶点以及相应的权值w（如果互相邻接则也要输入）：n”);

for(k=1;k<=G.arcnum;k++){fflush(stdin);

scanf(“%c%c %d”,&x,&y,&w);

i=LocateVex(G,x);j=LocateVex(G,y);

G.arcs[i][j].adj=w;

}//for

}//3.if

else{//3

printf(“请输入无向网的两个相邻的顶点（x,y）以及相应的权值w：n”);

for(k=1;k<=G.arcnum;k++){fflush(stdin);

scanf(“%c%c %d”,&x,&y,&w);

i=LocateVex(G,x);j=LocateVex(G,y);

G.arcs[i][j].adj=w;G.arcs[j][i].adj=G.arcs[i][j].adj;//逆向关联

}//for

}//3.else

}

return OK;}

/*··············在邻接表中插入节点··· ··········*/ int setList(int x,int y,ALGraph &G,int key[]){

int i,j,m,n;AList p,q;

m=LocateVex(G,x);//获取节点x对应的数组下标

n=LocateVex(G,y);

p=G.vertices[m].firstarc;//获取第m个链表的首节点

q=(AList)malloc(sizeof(ArcNode));//申请节点空间

if(!q)return ERROR;

q->nextarc=NULL;

q->adjvex=n;

while(key[m]&&p->nextarc){//key存储着该链表的长度，当其不为零时在首节点后插入新节点

p=p->nextarc;

key[m]++;//链表长度加1

}

if(!key[m]){G.vertices[m].firstarc=q;key[m]++;}//当链表长度为零时，新节点为首节点

else p->nextarc=q;

return 1;}

/*················· 创建邻接表··········*/ int CreatAList(ALGraph &G){ int i,j,m,n,key[MAX_VERTEX_NUM];char x,y,w;AList p,q;SetGraphKind(G,option);printf(“邻接表：请输入顶点的个数和弧的个数：”);scanf(“%d %d”,&G.vexnum ,&G.arcnum);if(G.vexnum>20){

printf(“您输入的顶点个数超过最大值”);

return ERROR;

} printf(“请输入个顶点：n”);for(i=1;i<=G.vexnum;i++){

fflush(stdin);

scanf(“%c”,&G.vertices[i].data);

G.vertices[i].firstarc=NULL;

key[i]=0;} if(G.kind==DG){//有向图

printf(“请输入弧（如AB,其中AB与BA是不同的弧）：n”);

for(j=1;j<=G.arcnum;j++){

fflush(stdin);

scanf(“%c%c”,&x,&y);//输入弧的两顶点

m=LocateVex(G,x);//将两顶点转换成数组下标

n=LocateVex(G,y);

p=G.vertices[m].firstarc;//获取第m个链表的首节点，及以第m个顶点为首节点的链表

q=(AList)malloc(sizeof(ArcNode));//申请节点存储空间

if(!q)return ERROR;

q->nextarc=NULL;

q->adjvex=n;

while(key[m]&&p->nextarc){//链表长度不为零，且下一个节点存在时，在首节点后插入新节点

p=p->nextarc;

key[m]++;

}

if(!key[m]){G.vertices[m].firstarc=q;key[m]++;}//链表长度为零时，新节点为首节点

else p->nextarc=q;

} } if(G.kind==UDG){

printf(“请输入弧（如AB,其中AB与BA是不同的弧）：n”);

for(j=1;j<=G.arcnum;j++){

fflush(stdin);

scanf(“%c%c”,&x,&y);

setList(x,y,G,key);

setList(y,x,G,key);

} }

if(G.kind==DN){

printf(“请输入依次输入弧以及这条弧的权值（如AB 8,其中AB与BA是不同的弧）：n”);

for(j=1;j<=G.arcnum;j++){

fflush(stdin);

scanf(“%c%c %d”,&x,&y,&w);

m=LocateVex(G,x);

n=LocateVex(G,y);

p=G.vertices[m].firstarc;

q=(AList)malloc(sizeof(ArcNode));

if(!q)return ERROR;

q->nextarc=NULL;

q->quan=w;

q->adjvex=n;

while(key[m]&&p->nextarc){

p=p->nextarc;

key[m]++;

}

if(!key[m]){G.vertices[m].firstarc=q;key[m]++;}

else p->nextarc=q;

} } if(G.kind==UDN){

printf(“无向网请输入依次输入弧以及这条弧的权值（如AB 8,其中AB与BA是不同的弧）：n”);

for(j=1;j<=G.arcnum;j++){

fflush(stdin);

scanf(“%c%c %d”,&x,&y,&w);

m=LocateVex(G,x);

n=LocateVex(G,y);

p=G.vertices[m].firstarc;

q=(AList)malloc(sizeof(ArcNode));

if(!q)return ERROR;

q->nextarc=NULL;

q->quan=w;

q->adjvex=n;

while(key[m]&&p->nextarc){

p=p->nextarc;

key[m]++;

}

if(!key[m]){G.vertices[m].firstarc=q;key[m]++;}

else p->nextarc=q;

int temp;

temp=m;

m=n;

n=temp;

p=G.vertices[m].firstarc;

q=(AList)malloc(sizeof(ArcNode));

if(!q)return ERROR;

q->nextarc=NULL;

q->quan=w;

q->adjvex=n;

while(key[m]&&p->nextarc){

p=p->nextarc;

key[m]++;

}

if(!key[m]){G.vertices[m].firstarc=q;key[m]++;}

else p->nextarc=q;

} } return OK;}

/*················· 判断以第v个顶点为首节点的链表是否存在··········*/ int FirstAdjVex(ALGraph G,int v){ if(G.vertices[v].firstarc)

} return G.vertices[v].firstarc->adjvex;//存在则返回首节点 return 0;/*················· 获取以第v个顶点为首节点的链表中的节点w的子节点··········*/ int NextAdjVex(ALGraph G,int v,int w){ AList s;s=G.vertices[v].firstarc;//获取链表的首节点v while(s->adjvex!=w)//当节点不是w时，指针后移直到找到节点w或到达最后一个节点

s=s->nextarc;if(s->nextarc)//跳出循环后，节点不为空，则表明找到了节点w，否则表示已至链表最后一个节点

return s->nextarc->adjvex;return 0;}

/*················· 遍历节点v的叶子节点··········*/ void DFS(ALGraph G,int v){ int w;visited[v]=1;printf(“%c ”,G.vertices[v]);//输出第v个顶点，并标记为已访问

for(w=FirstAdjVex(G,v);w>=1;w=NextAdjVex(G,v,w)){//遍历第v个顶点的子节点，并递归遍历子节点的子节点

if(!visited[w])DFS(G,w);

} }

/*················· 图的深度优先遍历··········*/ void DFSTraverse(ALGraph G){ int v;visited[0]=1;//数组的存储是从1开始的，数组【0】不使用

for(v=1;v<=G.vexnum;v++)visited[v]=0;//初始化各顶点的访问状态为未访问

for(v=1;v<=G.vexnum;v++)

if(!visited[v])DFS(G,v);//从第一个顶点开始遍历 }

/*················· 图的广度优先遍历··········*/ void BFSTraverse(ALGraph G){ int v,w,u;LinkQueue Q;for(v=1;v<=G.vexnum;v++)visited[v]=0;//初始化各顶点为未访问

visited[0]=1;//数组的存储是从1开始的，数组【0】不使用

InitQueue(Q);//创建队列

for(v=1;v<=G.vexnum;v++)//从第一个顶点开始遍历

if(!visited[v]){

visited[v]=1;

printf(“%c ”,G.vertices[v]);

EnQueue(Q,v);//将该顶点标记为已访问，输出，并加入到队列中

while(!QueueEmpty(Q)){//遍历队列中顶点的所有子节点

DeQueue(Q,u);//获取队首的顶点，赋值给U

for(w=FirstAdjVex(G,u);w>=1;w=NextAdjVex(G,u,w)){//遍历顶点U所有未访问的子节点

if(!visited[w]){

visited[w]=1;

printf(“%c ”,G.vertices[w]);

EnQueue(Q,w);//将子节点加入队列，以便遍历子节点的子节点

}//if

else break;

}//for

}//while }//if }

/*················· 计算各顶点入度··········*/ void FindInDegree(ALGraph G,int in[]){ int i,j,k;AList p;for(k=1;k<=G.vexnum;k++)in[k]=0;//初始化各顶点入度为0 for(i=1;i<=G.vexnum;i++){

p=G.vertices[i].firstarc;//获取个链表的首节点

while(p){//遍历链表的子节点

j=p->adjvex;//获取子节点

in[j]++;//子节点的入度加1

in[i]++;

p=p->nextarc;//指向下一子节点

} } }

/*················· 拓扑排序（打印输出）··········*/ int TopologicalSort(ALGraph G){ int i,k,count;AList p;SqStack S;

FindInDegree(G,indegree);//计算各顶点入度 InitStack(S);//创建栈 for(i=1;i<=G.vexnum;i++)

if(!indegree[i])Push(S,i);//寻找入度为0的点，并加入到栈中 count=0;//输出的顶点个数

if(StackEmpty(S))printf(“此有向图不符合条件！”);while(!StackEmpty(S)){

Pop(S,i);//从栈中取出顶点开始输出

printf(“%c ”,G.vertices[i].data);

++count;//输出的顶点个数加1

for(p=G.vertices[i].firstarc;p;p=p->nextarc){//将顶点i的子节点的入度减1

k=p->adjvex;

if(!(--indegree[k]))Push(S,k);//如子节点的入度减为0，则入栈

}

}

if(count<=G.vexnum)return ERROR;

else return OK;}

/*················· 求最小生成树··········*/ int Minimum(MGraph G,closedges m){ int i,j,min=INFINITY;for(i=1;i<=G.vexnum;i++){//从待选的可达集合中选取一条代价最小的边

if(m[i].lowcost){//到顶点i可达时执行，即到顶点的权值不为0

if(m[i].lowcost

min=m[i].lowcost;

j=i;

}

} }

return j;}

/*················· 最小生成树（普里姆算法实现）··········*/ void

MinSpanTree_PRIM(MGraph G,char u){ int i,j,k;closedges

closedge;

k=LocateVex(G,u);//获取初始顶点对应的数组下标

for(j=1;j<=G.vexnum;j++)//初始化辅助数组，计算从初始顶点到各顶点的最小代价

if(j!=k){

} closedge[j].adjvex=u;//u是已连通的顶点，表示该顶点J是同那个顶点连在一起 closedge[j].lowcost=G.arcs[k][j].adj;

closedge[k].lowcost=0;//顶点k到自身的最小代价设为0，即该顶点已加入最小生成树中

for(i=2;i<=G.vexnum;i++){

k=Minimum(G,closedge);//获取最小代价边连通的顶点

printf(“%c%c ”,closedge[k].adjvex,G.vexs[k]);//输出最小生成树的弧

closedge[k].lowcost=0;//该顶点已加入最小生成树中

for(j=1;j<=G.vexnum;j++)//将顶点k代入重新计算到待连通顶点的最小代价

if(G.arcs[k][j].adj

closedge[j].adjvex=G.vexs[k];

closedge[j].lowcost=G.arcs[k][j].adj;

}

} }

/*················· 对链表进行拓扑排序，并存储在栈中··········*/ int TopologicalOrder(ALGraph G,SqStack &T){ int i,j,k,count;SqStack S;

AList p;FindInDegree(G,indegree);InitStack(S);

for(i=1;i<=G.vexnum;i++)if(!indegree[i])Push(S,i);InitStack(T);count=1;for(i=1;i<=G.vexnum;i++)ve[i]=0;//初始化到达各顶点的总权值花销为0 while(!StackEmpty(S)){ Pop(S,j);Push(T,j);++count;

for(p=G.vertices[j].firstarc;p;p=p->nextarc){

k=p->adjvex;

if(--indegree[k]==0)Push(S,k);

if(ve[j]+p->quan>ve[k])ve[k]=ve[j]+p->quan;//顶点J的子节点K的总权值=顶点j的权值花销+弧的权值,即该顶点的最早发生时间

} } if(count<=G.vexnum)return ERROR;else return OK;}

/*················· 关键路径 int j

指向顶点的数组下标

int k

被指向顶点的数组下标标 int ee 最早发生时间 int el 最晚发生时间 int dut 事件持续时间

char tag 关键路径标识符，*表示该弧为关键路径 SqStack T 堆

Alist p

链表的节点

int v1[MAX_VERTEX_NUM] 顶点权值记录数组，及该顶点的最早发生时间 ··········*/ int CriticalPath(ALGraph G){ int i,j,k,ee,el,dut,v1[MAX_VERTEX_NUM];SqStack T;AList p;char tag;int str[10];int count=0;//声明一个数组来存放关键路径的各个节点，count表示当前数组使用长度，也可理解为下一节点的存放位置

if(!TopologicalOrder(G,T))return ERROR;//按拓扑排序将各顶点依次入栈

for(i=1;i<=G.vexnum;i++){//初始化各顶点的权值为最后一个顶点的总权值花销，即工程的总时间花销

v1[i]=ve[G.vexnum];} while(!StackEmpty(T))//按拓扑顺序出栈，分别计算各顶点的最晚发生时间

for(Pop(T,j),p=G.vertices[j].firstarc;p;p=p->nextarc){

k=p->adjvex;dut=p->quan;

if(v1[k]-dut

}

for(j=1;j<=G.vexnum;j++)//循环代入所有顶点，遍历其子节点，根据弧的权值，得到最早发生时间和最晚发生时间，并判断该弧是否为关键路径

for(p=G.vertices[j].firstarc;p;p=p->nextarc){

k=p->adjvex;dut=p->quan;

ee=ve[j];el=v1[k]-dut;

tag=(ee==el)?'*':' ';

printf(“%d %d %d %d %d %cn”,j,k,dut,ee,el,tag);

} /* 下面为非必需代码，功能为输出关键路径*/ if(count==0)//存储关键路径的第一个节点（第一个链接表的首节点——

str[count++]=j;if(tag=='*')//如果该弧为关键路径，则将该弧的被指向顶点存储到str中 { str[count++]=k;}

for(int n=0;n

printf(“%d”,str[n]);

printf(“->”);

}

return OK;}

//求关键路径

//Dijkstra算法

//求G（用邻接矩阵表示）中源点v到其他各顶点最短路径,n为G中顶点数 void Dijkstra(MGraph * G,PathType path[],int dist[],int v,int n){ int i,j,count,s[MAX_VERTEX_NUM],max,u;//s[n]用来标志源点到某顶点的最短路径是否求出

for(i=1;i<=n;i++){//1.初始化 s[i]=0;if(G->arcs[v][i].adj!=INFINITY)dist[i]=G->arcs[v][i].adj;else dist[i]=MAX_INT;//v到其他顶点的权为当前最短路径，送dist[i] path[i].pi[0]=v;path[i].end=0;}

dist[v]=0;s[v]=1;//源点到源点本身的最短路径求出 count=1;

while(count<=n-1){//求n-1条最短路径

max=MAX_INT;// MAX_INT为无穷大值，需要实际情况设置

for(j=1;j<=n;j++){//2.找当前最短路径长度 if(s[j]==0&&dist[j]

if(max==MAX_INT)break;//最短路径求完（不足n-1）条，跳出while循环 s[u]=1;//表示V到Vu最短路径求出 path[u].end++;path[u].pi[path[u].end]=u;for(j=1;j<=n;j++){//3.u求出后，修改dist和path向量，执行完后返回2，知道跳出循环 if(s[j]==0&&dist[j]>dist[u]+G->arcs[u][j].adj&&G->arcs[u][j].adj!=INFINITY){ dist[j]=dist[u]+G->arcs[u][j].adj;path[j]=path[u];} } count++;} }

/*················· 有向图的功能操作界面··········*/ void DG_(MGraph G1,ALGraph G2){ int i,j,k,m,key;AList s;char x,y;

for(k=0;;){

key=0;system(“cls”);//清空显示

printf(“**************************n”);

printf(“你选择了对有向图的基本操作及应用：n1创建邻接矩阵n2创建邻接表n3拓扑结构n4退出n”);

printf(“**************************n”);

printf(“请选择：”);

scanf(“%d”,&m);

switch(m){

case 1: CreatGraph(G1);printf(“有向图的邻接矩阵：n”);

for(i=1;i<=G1.vexnum;i++){//输出邻接矩阵

for(j=1;j<=G1.vexnum;j++){

printf(“ %d”,G1.arcs[i][j].adj);

}

printf(“n”);

}break;

case 2: CreatAList(G2);printf(“有向图的邻接表：n”);

for(i=1;i<=G2.vexnum;i++){//输出链接表

printf(“%c:”,G2.vertices[i]);

s=G2.vertices[i].firstarc;

while(s){

j=s->adjvex;fflush(stdin);

printf(“<%c ”,G2.vertices[i]);

printf(“%c> ”,G2.vertices[j]);

s=s->nextarc;

}

printf(“n”);

}break;

case 3:printf(“有向图的拓扑排序：n”);TopologicalSort(G2);break;case 4:key=1;break;} printf(“n”);

if(key)break;//跳出循环，返回上一层

system(“pause”);//暂停程序执行，直到监听到操作

}

printf(“nn”);}

//DG

/*················· 有向网的功能操作界面··········*/ void DN_(MGraph G1,ALGraph G2){ int i,j,k,m,key;AList s;

for(k=0;;){

key=0;

system(“cls”);

printf(“**************************n”);

printf(“你选择了对有向网的基本操作及应用：n1创建邻接矩阵n2创建邻接表n3关键路径n4最短路径n5退出n”);

printf(“**************************n”);

printf(“请选择：”);

scanf(“%d”,&m);

switch(m){

case 1: CreatGraph(G1);printf(“有向网的邻接矩阵：n”);

for(i=1;i<=G1.vexnum;i++){

for(j=1;j<=G1.vexnum;j++){

if(G1.arcs[i][j].adj==INT_MAX)printf(“ ∞”);

else printf(“ %d”,G1.arcs[i][j].adj);

}

printf(“n”);

}break;

case 2: CreatAList(G2);printf(“有向网的邻接表：n”);

for(i=1;i<=G2.vexnum;i++){

printf(“%c:”,G2.vertices[i]);

s=G2.vertices[i].firstarc;

while(s){

j=s->adjvex;fflush(stdin);

printf(“<%c ”,G2.vertices[i]);

printf(“%c> ”,G2.vertices[j]);

printf(“ %d ”,s->quan);

s=s->nextarc;

}

printf(“n”);

}break;

case 3: printf(“有向网关键路径：n”);CriticalPath(G2);break;

case 4:

{int i,j,v,count=0;//v为起点，n为顶点个数

char c;

PathType path[MAX_VERTEX_NUM];//v到各顶点的最短路径向量

int dist[MAX_VERTEX_NUM];//v到各顶点最短路径长度向量

printf(“请输入最短路径起点：”);

fflush(stdin);

scanf(“%c”,&c);

v=LocateVex(G1,c);

Dijkstra(&G1,path,dist,v,G1.vexnum);

for(i=1;i<=G1.vexnum;i++){

if(dist[i]!=0&&dist[i]!=MAX_INT)

{

printf(“%c到%c的最短路径:”,G1.vexs[v],G1.vexs[i]);

for(j=0;j<=path[i].end;j++){

printf(“%c ”,G1.vexs[path[i].pi[j]]);

}

printf(“n”);

printf(“最短路径长度:%d”,dist[i]);//输出为MAX_INT则表示两点间无路径

printf(“n”);

}

else count++;

}

if(count==G1.vexnum)printf(“该顶点无出度！”);

break;}

case 5:key=1;break;

}printf(“n”);

if(key)break;system(“pause”);}

printf(“nn”);}

//DN

/*················· 无向图的功能操作界面··········*/ void UDG_(MGraph G1,ALGraph G2){ int i,j,k,m,key;AList s;

for(k=0;;){

key=0;

system(“cls”);

printf(“**************************n”);

printf(“你选择了对无向图的基本操作及应用：n1创建邻接矩阵n2创建邻接表n3深度遍历n4广度遍历n5退出n”);

printf(“**************************n”);

printf(“请选择：”);

scanf(“%d”,&m);

switch(m){

case 1:CreatGraph(G1);printf(“无向图的邻接矩阵：n”);

for(i=1;i<=G1.vexnum;i++){

for(j=1;j<=G1.vexnum;j++){

printf(“ %d”,G1.arcs[i][j].adj);

}

printf(“n”);

}break;

case 2: CreatAList(G2);printf(“无向图的邻接表：n”);

for(i=1;i<=G2.vexnum;i++){

printf(“%c:”,G2.vertices[i]);

s=G2.vertices[i].firstarc;

while(s){

j=s->adjvex;fflush(stdin);

printf(“(%c ”,G2.vertices[i]);

printf(“%c)”,G2.vertices[j]);

s=s->nextarc;

}

printf(“n”);

}break;

case 3: printf(“无向图的深度优先遍历：n”);DFSTraverse(G2);printf(“n”);break;

case 4: printf(“无向图的广度优先遍历：n”);BFSTraverse(G2);break;

case 5: key=1;break;

}printf(“n”);

if(key)break;

system(“pause”);}

printf(“nn”);}

//UDG

/*················· 无向网的功能操作界面··········*/ void UDN_(MGraph G1,ALGraph G2){ int i,j,m,k,key;AList s;char u;

for(k=0;;){

key=0;

system(“cls”);

printf(“**********************************n”);

printf(“你选择了对无向网的基本操作及应用：n1创建邻接矩阵n2创建邻接表n3最小生成树n4退出n”);

printf(“**********************************n”);

printf(“请选择：”);

scanf(“%d”,&m);

switch(m){

case 1: CreatGraph(G1);printf(“无向网的邻接矩阵：n”);

for(i=1;i<=G1.vexnum;i++){

for(j=1;j<=G1.vexnum;j++){

if(G1.arcs[i][j].adj==INT_MAX)printf(“ ∞”);

else printf(“ %d”,G1.arcs[i][j].adj);

}

printf(“n”);

}break;

case 2: CreatAList(G2);printf(“无向网的邻接表：n”);

for(i=1;i<=G2.vexnum;i++){

printf(“%c:”,G2.vertices[i]);

s=G2.vertices[i].firstarc;

while(s){

j=s->adjvex;fflush(stdin);

printf(“(%c ”,G2.vertices[i]);

printf(“%c)”,G2.vertices[j]);

printf(“ %d ”,s->quan);

s=s->nextarc;

}

printf(“n”);

}break;

case 3: printf(“请输入第一个顶点：”);

fflush(stdin);

scanf(“%c”,&u);

printf(“无向网的最小生成树：n”);

MinSpanTree_PRIM(G1,u);break;

case 4: key=1;break;

}printf(“n”);

if(key)break;

system(“pause”);}

printf(“nn”);}

//UDN

/*················· 首界面··········*/ void main(){ MGraph

G1;

ALGraph

G2;int i,n;for(i=0;;){

n=0;

system(“cls”);

printf(“n”);

printf(“**************图的基本操作及应用***************n1：有向图的基本操作及应用n2：无向图的基本操作及应用n3：有向网的基本操作及应用n4：无向网的基本操作及应用n5: 退出n”);

printf(“********************************n”);

printf(“请选择：”);

scanf(“%d”,&option);

printf(“nn”);

switch(option){

case 1: DG_(G1,G2);break;

case 2: UDG_(G1,G2);break;

case 3: DN_(G1,G2);break;

case 4: UDN_(G1,G2);break;

case 5: n=1;break;

default: printf(“你输入的编码有误！”);break;

}

if(n)break;

printf(“nn”);} }

第四篇：注释格式

一、中文专著、学位论文、学术报告

序号、作者.文献题名.版本.出版地：出版者，出版年：起止页码。例如：

1、刘少奇.论共产党员的修养.修订2版.北京：人民出版社，1962：50。

2、张三.物权立法的本土资源研究.<博士论文>.北京：中国人民大学，2008：27-28。

二、中文期刊文章

序号、作者.文献题名.刊名，年，卷（期）：起止页码。

例如：

3、李国海.论反垄断法制裁手段及其范围.中南大学学报（社会科学版），2005（2）:193-198。

三、中文专著及论文集中的析出文献

序号、析出文献主要责任者．析出文献题名．载：原文献主要责任者．原文献题名．版本．出版地：出版者，出版年：析出文献起止页码

例如：

4、张光斗．也谈21世纪高等工程教育的改革．见：林功实．立足国内培养跨世纪研究生．北京：北京理工大学出版社，1996：105～110。

四、电子文献

序号、主要责任者.电子文献题名.电子文献的出处或可获得地址，发表或更新日期/引用日期（任选）。

5、王明亮.关于中国学术期刊标准化数据库系统工程的进展.http://,1998-10-04

五、外文文献

所引用语种通常注释体例。例如：

6、Scholkopf B, Smola，A.Learning with Kernels.Cambridge: MIT Press, 2002

注释格式如下：

引自期刊： ① 作者 ： 《题名》，《刊名》，××××年第 ×期，第 × 页

引自专著： ② 作者 ： 《书名》，出版者及×××× 年版，第 × 页

引自报纸： ③ 作者 ： 《题名》，《报纸名》年-月-日（版次）参考文献著录格式如下：

引自期刊：［ 1］ 作者（所有作者全列—下同）.题名［ J］.刊名 , 出刊年 ,卷(期): 起止页码.引自专著：［2］ 作者.书名［ M］.版次（初版不写）.译者（指译著, 所有译者全列）.出版地 : 出版者 , 出版年.页码.引自报纸：［3］ 作者.题名［ N］.报纸名 , 年-月-日（版次）.引自论文集：［4］ 作者.题名［ A］.见 : 论文集编者.文集名［ C］.出版地 : 出版者 , 出版年

第五篇：部门代码

部门代码

总经理：GMD 行政人事部：AD 技术部：TD 发展部：RDD 宣传部：PD 策划部：SD 工程部：ED 造价部：EC 财务部：ACD 投融资部：FD 战略计划部：SPD 招标合约部：BCD 审计部：ADD 招商部：MD 研究院：RI 物业部:PD 后勤部：LD 资源管理部：RD

下载代码注释格式（合集）word格式文档
下载代码注释格式（合集）.doc
将本文档下载到自己电脑，方便修改和收藏，请勿使用迅雷等下载。
点此处下载文档

文档为doc格式
相关专题 代码注释模板 代码注释图案

声明：本文内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：645879355@qq.com 进行举报，并提供相关证据，工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

相关范文推荐

    代码检查

    代码检查 摘要：代码检查是白盒测试的一种静态测试方法，是众多软件测试方法中发现软件缺陷最有效的方法之一。本文结合国内外学者在相关领域的研究情况，介绍代码检查相关的基本......

    代码工作计划（精选合集）

    2015年个人年度工作计划 自从2014年年初进入公司工作以来，在公司领导的关怀和指导下，在公司部分同事的大力支持下，我在工作和生活上都学到了很多。 2015年公司将全面壮大，各项......

    中学代码

    010407师大附中 010301西安市第一中学 010202西安市第八十三中 010527西安中学 010101西安高级中学 碑林区 学校代码学校名称 010101西安高级中学（重点） 010102西工大附中（重点......

    注释-中西部+格式

    格式： 专著：[12]王沪宁.反腐败:中国实验[M].海口:三环出版社,1990. 期刊： 张玉胜.“一把手”分权,筑牢反腐制度笼子[J].四川党的建设(农村版),2014,. 论文： 黎宇.我国......

    参考文献注释格式

    参考文献和注释的标注格式1．参考文献格式： 按照专著、论文的顺序依照出版或发表时间排列，也可根据主题类型排列（如把有关一般理论方法的放在一起，把有关具体对象的评论和研究著......

    论文注释格式

    同济大学政治与国际关系学院 研究生学位论文注释格式规范 一、封面 二、论文内容摘要及关键词 注意：自内容摘要起至正文第一页前用罗马数字标识页数 三、目录 1、正文内容......

    注释格式、体例

    注释体例 （一）中文注释 首次注释时，中文文献的标注次序为：作（编）者姓名、文献名、卷册序号、出版单位、出版时间、页码。再次引用同一中文文献时，则仅标注作（编）者、文献名、页码即可......

    英文注释

    英文注释： 1、当首次引用一本著作的资料时，注释中须将该书的作者姓名、书名、出版地、出版者、出版年代及资料所在页码顺序注明。具体格式如下：（1）专著类： Harold U. Faulkner,......