数据结构笔记3

1.串

str.h

1. //str.h   
2.     
3. #ifndef _STR_H   
4. #define _STR_H   
5.     
6. typedef struct  
7. {   
8.     char *ch;   
9.     int len;   
10. }STR;   
11.     
12. STR *NewStr(char *str);   
13. void DestroyStr(STR *s);   
14. void ClearStr(STR* s);   
15. int StrCompare(STR *s,STR *t);   
16. int StrCancat(STR *s,STR *t);   
17. STR *SubStr(STR *s,int pos,int len);   
18.     
19. #endif  

str.c

1. //str.c   
2.     
3. #include<stdio.h>   
4. #include<stdlib.h>   
5. #include "str.h"   
6.     
7. STR *NewStr(char *str) //新建一个串   
8. {   
9.     STR *s=NULL;   
10.     int i;   
11.     s=(STR *)malloc(sizeof(STR));   
12.     if(s==NULL)   
13.         return NULL;   
14.     for(i=0;str[i];++i);   
15.     s->ch=(char *)malloc((i+1)*sizeof(char));   
16.     if(s->ch==NULL)   
17.     {   
18.         free(s);   
19.         return NULL;   
20.     }   
21.     s->len=i;   
22.     while(i>=0)   
23.     {   
24.         s->ch[i]=str[i];   
25.         --i;   
26.     }   
27.     return s;   
28. }   
29.     
30. void DestroyStr(STR *s) //销毁串   
31. {   
32.     free(s->ch);   
33.     s->ch=NULL;   
34.     s->len=0;   
35. }   
36.     
37. void ClearStr(STR* s)   
38. {   
39.     free(s->ch);   
40.     s->ch=NULL;   
41.     s->len=0;   
42. }   
43.     
44. int StrCompare(STR *s,STR *t)//比较串   
45. {   
46.     int i;   
47.     for(i=0;i<s->len && i<t->len;i++)   
48.         if(s->ch[i]!=t->ch[i])   
49.             return s->ch[i]-t->ch[i];   
50.     return s->len-t->len;   
51. }   
52.     
53. int StrCancat(STR *s,STR *t)//连接两个串   
54. {   
55.     int i;   
56.     char *temp=NULL;   
57.     temp=(char *)malloc((s->len+t->len+1)*sizeof(char));   
58.     if(temp==NULL) return 0;   
59.     for(i=0;i<s->len;i++)   
60.         temp[i]=s->ch[i];   
61.     for(;i<s->len+t->len;i++)   
62.         temp[i]=t->ch[i-s->len];   
63.     temp[i]=0; //在最后加上'\0'   
64.     ClearStr(s);   
65.     s->ch=temp;   
66.     s->len=i;   
67.     return 1;   
68. }   
69.     
70. STR *SubStr(STR *s,int pos,int len) //获取子串   
71. {   
72.     STR *t=NULL;   
73.     if(pos<1||pos>s->len||len<0||len>s->len-pos+1)   
74.         return NULL;   
75.     t=NewStr("");   
76.     ClearStr(t);   
77.     t->ch=(char *)malloc((len+1)*sizeof(char));   
78.     if(t->ch==NULL) return NULL;   
79.     t->len=len;   
80.     for(--len;len>=0;--len)   
81.         t->ch[len]=s->ch[pos-1+len];   
82.     t->ch[t->len]=0;   
83.     return t;   
84. }

main.c

1. //main.c   
2.     
3. #include<stdio.h>   
4. #include<stdlib.h>   
5. #include "str.h"   
6.     
7. void main()   
8. {   
9.     int res;   
10.     STR *t=NULL,*s=NewStr("hello");   
11.     printf("s=%s,len=%d\n",s->ch,s->len);   
12.     t=NewStr("hello");   
13.     res=StrCompare(s,t);   
14.     if(res==0)   
15.         printf("s=t\n");   
16.     else if(res>0)   
17.         printf("s>t\n");   
18.     else  
19.         printf("s<t\n");   
20.     ClearStr(t);   
21.     t=NewStr("world");   
22.     StrCancat(s,t);   
23.     printf("s=%s,len=%d\n",s->ch,s->len);   
24.     DestroyStr(t);   
25.     
26.     t=SubStr(s,2,5);   
27.     printf("t=%s,len=%d\n",t->ch,t->len);   
28.     
29.     DestroyStr(s);   
30. }

2.树

tree.h

1. //tree.h   
2.     
3. #ifndef _TREE_H   
4. #define _TREE_H   
5.     
6. typedef struct _node  //定义树的结点   
7. {   
8.     void *data;   
9.     struct _node *parent;   
10.     struct _node *child;   
11.     struct _node *next;   
12. }TREE;   
13.     
14. int InsertTree(TREE **t,void *data,int size);   
15. int DeleteAllTree(TREE *t);   
16. int DeleteTree(TREE *t);   
17. TREE *GetTreeByKey(TREE *r,void *key,int(*compare)(void*,void *data));   
18. int PrintTree(TREE *t,void(*print)(void *));   
19.     
20.     
21. #endif  

tree.c

1. //tree.c   
2.     
3. #include<stdio.h>   
4. #include<stdlib.h>   
5. #include<string.h>   
6. #include "tree.h"   
7.     
8. int InsertTree(TREE **t,void *data,int size)   
9. //第1个参数为目录指针变量的地址，第2个参数数据无类型，第3个参数数据的大小   
10. {   
11.     TREE *p=(TREE *)malloc(sizeof(TREE));   
12.     if(p==NULL) return 0;   
13.     memset(p,0,sizeof(TREE));   
14.     p->data=malloc(size);   
15.     if(p->data==NULL)   
16.     {   
17.         free(p);   
18.         return 0;   
19.     }   
20.     memcpy(p->data,data,size);   
21.     //以上是创建一个新的结点   
22.     //--------------------------------   
23.     //以下是把数据存到新结点中去   
24.     if(*t==NULL) //如果目录结点为空   
25.         *t=p;   
26.     else if((*t)->child==NULL)//如果树中只有根结点   
27.     {   
28.         p->parent=*t;   
29.         (*t)->child=p;   
30.     }   
31.     else  
32.     {   
33.         TREE *tmp=(*t)->child;   
34.         while(tmp->next) //循环到这一层的最后一个结点   
35.             tmp=tmp->next;   
36.         tmp->next=p;   
37.         p->parent=*t;   
38.     }   
39.     return 1;   
40. }   
41.     
42. int DeleteAllTree(TREE *t) //删除整棵树   
43. {   
44.     TREE *p=NULL;   
45.     while(t)//当树不为空时，往下做，直到树为空   
46.     {   
47.         if(t->child!=NULL)//如果子结点不为空   
48.         {   
49.             p=t->child->child;   
50.             while(p->next)//这个循环使p指向t的孙子结点下的最后一个   
51.                 p=p->next;   
52.             //此时p已指向t的孙子结点下的最后一个   
53.             p->next=t->child->next;//将此时p的下一个指向t的子结点的下一个(即t的最右子结点)   
54.             t->child->next=NULL;//将指向t子结点的兄弟结点清空   
55.         }   
56.         p=t->child;//将t的子结点赋给p指针,以记录t的子结点   
57.         free(t->data);   
58.         free(t);   
59.         t=p; //将p重新赋给t指针   
60.     }   
61.     return 1;   
62. }   
63.     
64. int DeleteTree(TREE *t)//删除一个树结点   
65. {   
66.     if(t==NULL) return 0;   
67.     if(t->parent==NULL) //如果t为根结点   
68.         ;   
69.     else if(t==t->parent->child)//如果t是某一层的第一个结点   
70.         t->parent->child=t->next;//将t的下一个挂到t的位置   
71.     else  
72.     {   
73.         TREE *p=t->parent->child;//将t结点所在的这一层的第1个兄弟结点赋给p   
74.         while(p->next==t)//p往下找，直到找到p的下一个是t结点，即找到t的上一个   
75.             p=p->next;   
76.         p->next=t->next;//把p的上一个的next指针指向t的下一个，这样就从树中删除了t结点   
77.     }   
78.     DeleteAllTree(t);   
79.     return 1;   
80. }   
81.     
82. TREE *GetTreeByKey(TREE *r,void *key,int(*compare)(void*,void *data))//查找结点   
83. {   
84.     if(r==NULL)   
85.         return NULL;   
86.     if(compare(r->data,key))   
87.         return r;   
88.     if(GetTreeByKey(r->child,key,compare))   
89.         return r->child;   
90.     if(GetTreeByKey(r->next,key,compare))   
91.         return r->next;   
92.     return NULL;   
93. }   
94.     
95. int PrintTree(TREE *t,void(*print)(void *))//打印树   
96. {   
97.     int i=0;   
98.     TREE *p=t->child;   
99.     while(p)   
100.     {   
101.         print(p->data);   
102.         i++;   
103.         p=p->next;//让p指向它的兄弟   
104.     }   
105.     return i;   
106. }

main.c

1. //main.c   
2.     
3. //用树表示目录层次   
4.     
5. #include<stdio.h>   
6. #include<stdlib.h>   
7. #include<string.h>   
8. #include "tree.h"   
9.     
10. TREE *root=NULL,*curDir=NULL;//根目录、当前目录   
11.     
12. void ParseMkdir(char *com)//创建目录   
13. {   
14.     if(InsertTree(&curDir,&com[6]/*从Mkdir 后一个字符开始截取*/,strlen(&com[6])+1)==0)   
15.     {   
16.         printf("命令操作失败！\n");   
17.     }   
18. }   
19.     
20. int CompareDir(void *data,void *key)   
21. {   
22.     return strcmp((char*)data,(char *)key)==0?1:0;   
23. }   
24.     
25. void ParseRmdir(char *com)//删除目录   
26. {   
27.     TREE *p=GetTreeByKey(root,&com[6],CompareDir);   
28.     if(p==NULL)   
29.         printf("文件不存在！");   
30.     DeleteTree(p);   
31. }   
32.     
33. void ParseCd(char *com)//切换目录   
34. {   
35. }   
36.     
37. void PrintDir(void *data)//打印目录   
38. {   
39.     printf("%10s",(char*)data);   
40. }   
41.     
42. void ParseLs(char *com)//查看目录   
43. {   
44.     if(PrintTree(curDir,PrintDir)==0)   
45.         printf("没有目录！");   
46.     printf("\n");   
47. }   
48.     
49.     
50. void main()   
51. {   
52.     char str[1024];   
53.     InsertTree(&root,"/",2);   
54.     curDir=root;   
55.     while(1)   
56.     {   
57.         printf("mkdir创建目录;\nrmdir删除目录;\nls查看目录;\ncd切换目录;\nexit退出\n");   
58.         printf(">>>:");   
59.         gets(str);   
60.         fflush(stdin);   
61.         if(strstr(str,"mkdir")==str)   
62.             ParseMkdir(str);   
63.         else if(strstr(str,"rmdir")==str)   
64.             ParseRmdir(str);   
65.         else if(strstr(str,"cd")==str)   
66.             ParseCd(str);   
67.         else if(strstr(str,"ls")==str)   
68.             ParseLs(str);   
69.         else if(strstr(str,"exit")==str)   
70.         {   
71.             printf("bey!\n");   
72.             exit(0);   
73.         }   
74.         else  
75.             printf("command not find!\n");   
76.     }   
77. }

3.二叉树

tree.h

1. //tree.h   
2.     
3. #ifndef _TREE_H   
4. #define _TREE_H   
5.     
6. typedef struct node   
7. {   
8.     char data;   
9.     struct node *lchild,*rchild;   
10. }TREE;   
11.     
12. TREE *MakeTree();   
13. void PrintTreeByBefore(TREE *t);   
14.     
15. #endif  

tree.c

1. //tree.c   
2.     
3. #include <stdio.h>   
4. #include <conio.h>   
5. #include <stdlib.h>   
6. #include "tree.h"   
7. #include "stack.h"   
8.     
9. TREE *MakeTree()   
10. {   
11.     TREE *t=NULL;   
12.     char ch;   
13.     ch=getche();//读取字符并显示   
14.     if(ch=='#')   
15.         return NULL;   
16.     t=(TREE*)malloc(sizeof(TREE));   
17.     if(t==NULL) return NULL;   
18.     t->data=ch;   
19.     t->lchild=MakeTree();   
20.     t->rchild=MakeTree();   
21.     return t;   
22. }   
23.     
24. void PrintTreeByBefore(TREE *t) //先序打印   
25. {   
26.     if(t==NULL)   
27.         return;   
28.     printf("[%c]",t->data);   
29.     PrintTreeByBefore(t->lchild);   
30.     PrintTreeByBefore(t->rchild);   
31. }   
32.     
33. void PrintTreeByMid(TREE *t)//中序方式   
34. {   
35.     TREE *p=t;   
36.     STACK* s=InitStack();   
37.     Push(s,&t);//将根地址压到栈中   
38.     while(!IsEmpty(s))   
39.     {   
40.         while(p)   
41.         {   
42.             p=p->lchild;   
43.             Push(s,&p);//将p左结点压到栈中   
44.         }   
45.         Pop(s,&p);   
46.         if(!IsEmpty(s))   
47.         {   
48.             Pop(s,&p);   
49.             printf("[%c]",p->data);   
50.             p=p->rchild;   
51.             Push(s,&p);   
52.         }   
53.     }   
54.     DestroyStack(s);   
55. }   
56.     
57. void main()   
58. {   
59.     TREE *tree=MakeTree();   
60.     PrintTreeByBefore(tree);   
61.     printf("\n*******************\n");   
62.     PrintTreeByMid(tree);   
63.     printf("\n");   
64. }

stack.h

1. //stack.h   
2.     
3. #ifndef _STACK_H   
4. #define _STACK_H   
5.     
6. #include "tree.h"   
7.     
8. #define ElemType TREE*   
9.     
10. #define STACK_INIT_SIZE 10   
11. #define STACK_INCREME 10   
12.     
13. typedef struct  
14. {   
15.     ElemType *base;   
16.     ElemType *top;   
17.     int size;   
18. }STACK;   
19.     
20. STACK *InitStack();   
21. void DestroyStack(STACK *s);   
22. int Push(STACK *s,ElemType *e);   
23. int Pop(STACK *s,ElemType *e);   
24. int IsEmpty(STACK *s);   
25.     
26. #endif  

stack.c

1. //stack.c   
2.     
3. #include<stdio.h>   
4. #include<stdlib.h>   
5. #include "stack.h"   
6.     
7. STACK * InitStack() //初始化一个栈   
8. {   
9.     STACK *s=(STACK*)malloc(sizeof(STACK));//初始化一个栈   
10.     if(s==NULL)   
11.         exit(0);   
12.     s->base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));//为栈分配一个初始大小   
13.     if(s->base==NULL) //如果栈底指针指向空   
14.         exit(0);   
15.     s->top=s->base; //空栈，使栈底与栈顶指针相同   
16.     s->size=STACK_INIT_SIZE;   
17.     return s;   
18. }   
19.     
20. void DestroyStack(STACK *s) //销毁一个栈   
21. {   
22.     free(s->base);   
23.     free(s);   
24. }   
25.     
26. int Push(STACK *s,ElemType *e) //压栈   
27. {   
28.     if(s==NULL||e==NULL) //判断传入的参数是否合法   
29.         return 0;   
30.     if(s->top-s->base>=s->size)//如果满栈   
31.     {   
32.         s->base=(ElemType*)realloc(s->base,   
33.             (s->size+STACK_INCREME)*sizeof(ElemType));//重新分配栈的大小   
34.         if(s->base==NULL)//如果分配失败，返回零   
35.             return 0;   
36.         s->top=s->base+s->size;//重置栈顶指针   
37.         s->size=s->size+STACK_INCREME;//重置栈大小   
38.     }   
39.     /*  
40.     //写法一  
41.     *s->top=*e;//将数据存到栈顶  
42.     s->top++; //栈顶上移  
43.     */  
44.     //写法二   
45.     *s->top++=*e;   
46.     return 1;   
47. }   
48.     
49. int Pop(STACK *s,ElemType *e) //出栈   
50. {   
51.     if(s==NULL||e==NULL)//判断传入的参数是否合法   
52.         return 0;   
53.     if(s->base==s->top) return 0; //如果是空栈，返回   
54.     *e= *--s->top; //将栈顶元素存到*e中   
55.     return 1;   
56. }   
57.     
58. int IsEmpty(STACK *s) //判断栈是否为空   
59. {   
60.     return s->top==s->base ? 1:0;   
61. } 

4. 查找二叉树

tree.h

1. //tree.h   
2.     
3. #ifndef _TREE_H   
4. #define _TREE_H   
5.     
6. typedef int ElemType;   
7.     
8. typedef struct treenode   
9. {   
10.     ElemType data;   
11.     struct treenode *left;   
12.     struct treenode *right;   
13. }TREE;   
14.     
15. TREE *MakeEmptyTree();   
16. TREE *InsertTreeNode(ElemType e,TREE *t);   
17. TREE *FindTreeNode(ElemType e,TREE *t);   
18. TREE *FindMax(TREE *t);   
19. TREE *FindMin(TREE *t);   
20. TREE *DeleteTreeNode(ElemType e,TREE *t);   
21. void DeleteTree(TREE **t);   
22.     
23. #endif  

tree.c

1. //tree.c   
2.     
3. #include <stdio.h>   
4. #include <stdlib.h>   
5. #include "tree.h"   
6.     
7. TREE *MakeEmptyTree() //创建一个空树   
8. {   
9.     return NULL;   
10. }   
11.     
12. TREE *InsertTreeNode(ElemType e,TREE *t) //插入树结点   
13. {   
14.     if(t==NULL) //如果是空树   
15.     {   
16.         t=(TREE *)malloc(sizeof(TREE));   
17.         if(t==NULL) return NULL; //如果没分配成功   
18.         t->data=e;   
19.         t->left=t->right=NULL;   
20.     }   
21.     else if(e<t->data) //如果小于树结点   
22.     {   
23.         t->left=InsertTreeNode(e,t->left); //插入树左边   
24.     }   
25.     else //否则   
26.         t->right=InsertTreeNode(e,t->right); //插入树右边   
27.     return t;   
28. }   
29.     
30. TREE *FindTreeNode(ElemType e,TREE *t) //查找结点   
31. {   
32.     if(t==NULL) return NULL; //如果树为空   
33.     if(t->data==e)  //如果查找的是根结点   
34.         return t;   
35.     else if(t->data<e) //大于根   
36.         return FindTreeNode(e,t->right);//去右边找   
37.     else    //否则   
38.         return FindTreeNode(e,t->left); //去左边找   
39. }   
40.     
41. TREE *FindMax(TREE *t) //查找树的最大值   
42. {   
43.     if(t==NULL) //如果是空树   
44.         return NULL;   
45.     if(t->right==NULL) //如果右子树为空   
46.         return t;   
47.     return FindMax(t->right); //否向右边找   
48. }   
49.     
50. TREE *FindMin(TREE *t) //查找树的最小值   
51. {   
52.     if(t==NULL) return NULL; //如果树为空   
53.     if(t->left==NULL) //如果左子树为空   
54.         return t;   
55.     return FindMin(t->left); //否则向左边找   
56. }   
57.     
58. TREE *DeleteTreeNode(ElemType e,TREE *t)   
59. {   
60.     TREE *p=NULL;   
61.     if(t==NULL) return NULL; //如果树为空   
62.     if(t->data>e) //小于根   
63.         t->left=DeleteTreeNode(e,t->left); //去左边删除   
64.     else if(t->data<e) //大于根   
65.         t->right=DeleteTreeNode(e,t->right);//去右边删除   
66.     else if(t->left && t->right) //当等于当前结点，且其左右子树均不为空   
67.     {   
68.         p=FindMin(t->right);//查找右子树的最小值   
69.         t->data=p->data; //将右子树的数据赋给当前找到的结点   
70.         t->right=DeleteTreeNode(t->data,t->right);   
71.         //到结点的右子树去删除数据为最小值的那个结点，并将删除之后的结果赋给右子树   
72.     }   
73.     else //当等于当前结点，且其左右子树有空   
74.     {   
75.         if(t->left==NULL)//如果左子树为空   
76.             t=t->right;//将右子树取代找到的结点   
77.         else if(t->right==NULL)//如果右子树为空   
78.             t=t->left;//将左子树取代找到的结点   
79.         free(t);//释放找到的结点   
80.         return NULL;   
81.     }   
82.     return t;   
83. }   
84.     
85. void DeleteTree(TREE **t) //删除整棵树   
86. {   
87.     if(*t==NULL)   
88.         return ;   
89.     DeleteTree(&(*t)->left);   
90.     DeleteTree(&(*t)->right);   
91.     free(*t);   
92.     *t=NULL;   
93. }

test.c

1. //test.c   
2.     
3. #include <stdio.h>   
4. #include <stdlib.h>   
5. #include "tree.h"   
6.     
7. void main()   
8. {   
9.     int n;   
10.     TREE *p,*tree=MakeEmptyTree();   
11.     while(1)   
12.     {   
13.         printf("Please enter a num:");   
14.         fflush(stdin);   
15.         if(scanf("%d",&n)!=1)   
16.             break;   
17.         if(n==0)   
18.             break;   
19.         tree=InsertTreeNode(n,tree);   
20.     }   
21.     printf("Max of tree is %d,Min of tree is %d\n",   
22.         FindMax(tree)->data,FindMin(tree)->data);   
23.     
24.     fflush(stdin);   
25.     printf("Please enter search num:");   
26.     scanf("%d",&n);   
27.     if(FindTreeNode(n,tree))   
28.         printf("find %d\n",n);   
29.     else  
30.         printf("not find\n");   
31.     p=DeleteTreeNode(n,tree);   
32.     if(p)   
33.         printf("delete %d success\n",n);   
34.     else  
35.         printf("delete fail\n");   
36.     DeleteTree(&tree);   
37.     if(tree==NULL)   
38.         printf("delete success\n");   
39.     else  
40.         printf("delete faile\n");   
41. }

5.图

demo中的图结构

main.c

1. //main.c   
2.     
3. #include<stdio.h>   
4.     
5. #define MAX 10000   
6. #define N 6   
7.     
8. int G[N][N]=   
9. {   
10.     {MAX,MAX,10,MAX,30,100}, //表示v0分别到各个顶点的距离   
11.     {MAX,MAX,5,MAX,MAX,MAX}, //表示v1分别到各个顶点的距离   
12.     {MAX,MAX,MAX,50,MAX,MAX},//表示v2分别到各个顶点的距离   
13.     {MAX,MAX,MAX,MAX,MAX,10},//表示v3分别到各个顶点的距离   
14.     {MAX,MAX,MAX,20,MAX,60}, //表示v4分别到各个顶点的距离   
15.     {MAX,MAX,MAX,MAX,MAX,MAX}//表示v5分别到各个顶点的距离   
16. }; //图的矩阵图,行标表示起始顶点，列标表示终止顶点   
17.     
18. int p[N][N]=   
19. {   
20.     {0,0,0,0,0,0},//第1行表示v0到v0所需要经过的路径的顶点   
21.     {0,0,0,0,0,0},//第2行表示v0到v1   
22.     {0,2,0,0,0,0},//第3行表示v0到v2,因为v0能直接到达v2,则直接在第2列上填2,第1表示v0本身   
23.     {0,0,0,0,0,0},//第4行表示v0到v3   
24.     {0,4,0,0,0,0},//第5行表示v0到v4,因为v0能直接到达v4,则直接在第2列上填4   
25.     {0,5,0,0,0,0} //第6行表示v0到v5,因为v0能直接到达v5,则直接在第2列上填5   
26. }; //用于存放第1个顶点到达其它顶点的最短距离经过的路径   
27.    //能从v0直接到达的初始化时写上，如上   
28.     
29. void main()   
30. {   
31.     int d[N]={MAX,MAX,10,MAX,30,100};//表示v0分别到各个顶点的距离   
32.     int flag[N]={0};   
33.     int i,v,min,k;   
34.     for(i=1;i<N;i++) //找出(第1个顶点到第i个顶点)的最短距离   
35.     {   
36.         min=MAX;   
37.         for(k=0,v=0;k<N;k++) //循环比较   
38.         {   
39.             if(flag[k]!=1 && min>d[k])   
40.             //如果(第1个顶点到第k个顶点)的最短距离没有比较过,且min大于(第1个顶点到第k个顶点)的最短距离   
41.             {   
42.                 min=d[k]; //将(第1个顶点到第k个顶点)的最短距离的值赋给min   
43.                 v=k; //将下标k存到v中   
44.             }   
45.         }//循环全部比较出来之后   
46.         flag[v]=1;//每循环1次，将flag[v]置1表示(第1个顶点到第v个顶点)的最短距离已经比较过了   
47.         d[v]=min;//将比较后的(第1顶点到第v个顶点)的直接最小距离存到d[v]中   
48.     
49.         for(k=0;k<N;k++) //循环比较,找出(第1个顶点到第k个顶点)最小的间接距离   
50.         {   
51.             if(flag[k]!=1 && min+G[v][k]<d[k]) //当存在间接距离小于直接距离   
52.             //   
53.             {   
54.                 d[k]=min+G[v][k]; //则把间接距离赋给d[k]   
55.                 if(p[k][0]==0)//如果原来没有被设置过   
56.                 {   
57.                     p[k][0]=1;   
58.                     p[k][1]=v;//经过第v个顶点，将v设置到第2列   
59.                     p[k][2]=k;//将k设置到第3列   
60.                 }   
61.                 else //否则,即p[v][i]原来被设置过   
62.                 {   
63.                     i=1;   
64.                     while(p[v][i])//   
65.                     {   
66.                         p[k][i]=p[v][i];//将新得到的间接顶点设置到原来的最终顶点上   
67.                         i++;//   
68.                     }   
69.                     p[k][i]=k;//将最终的顶点设置到p[k][i]   
70.                 }   
71.             }   
72.         }   
73.     }   
74.          
75.     for(i=0;i<N;i++) //这个循环打印v0到其它顶点的最小出距离   
76.         printf("%5d",d[i]);   
77.     printf("\n\n");   
78.     
79.     for(i=1;i<N;i++) //这个循环打印v0到其它顶点经过的结点顺序   
80.     {   
81.         printf("v0-->v%d:::",i);   
82.         for(v=1;v<N;v++)   
83.         {   
84.             printf("%5d",p[i][v]);   
85.         }   
86.         printf("\n");   
87.     }   
88. }