qq_16542775
qq_16542775

各种基本算法实现小结（四）—— 图及其遍历

各种基本算法实现小结（四）—— 图及其遍历

（均已测试通过）

 

====================================================================

图——深度优先和广度优先算法

无向图用二维邻接矩阵表示

 

测试环境：VC 6.0 (C)

[cpp]  view plain  copy
 print ?
  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3. #include <stdlib.h>  
  4. #define INFINITY 32767  
  5. #define MAX_VEX 20  
  6. #define QUEUE_SIZE (MAX_VERTEX+1)  
  7. #define DataType char  /* vertext's info  */  
  8. int *visited; /* Node: visited flag with dynamic array, good idea ! */  
  9. /* init queue for bfs */  
  10. struct _node  
  11. {  
  12.     int v_num;  
  13.     struct _node *next;  
  14. };  
  15. typedef struct _node node, *pnode;  
  16. struct _queue  
  17. {  
  18.     pnode front;  
  19.     pnode rear;  
  20. };  
  21. typedef struct _queue queue, *pqueue;  
  22. struct _graph  
  23. {  
  24.     DataType *vexs;  
  25.     int arcs[MAX_VEX][MAX_VEX];  
  26.     int vexnum, arcnum;  
  27. };  
  28. typedef struct _graph graph, *pgraph;  
  29. /* operation of queue */  
  30. queue init_queue()  
  31. {  
  32.     queue qu;  
  33.     qu.front=qu.rear=(pnode)malloc(sizeof(node));  
  34.     if(qu.front == NULL)  
  35.         exit(1);  
  36.     qu.rear->next=NULL;  
  37.     return qu;  
  38. }  
  39. void en_queue(pqueue pqu, int v_num)  
  40. {  
  41.     pnode pn;  
  42.     pn=(pnode)malloc(sizeof(node));  
  43.     if(pqu->front == NULL)  
  44.         exit(1);  
  45.     pn->v_num=v_num;  
  46.     pn->next=NULL;  
  47.     pqu->rear->next=pn;  
  48.     pqu->rear=pqu->rear->next;  
  49. }  
  50. int isempty_queue(pqueue pqu)  
  51. {  
  52.     if(pqu->front == pqu->rear)  
  53.         return 1;  
  54.     else  
  55.         return 0;  
  56. }  
  57. int de_queue(pqueue pqu)  
  58. {  
  59.     pnode pn;  
  60.     int d;  
  61.     if(isempty_queue(pqu))  
  62.         return -1;  
  63.     pn=pqu->front;  
  64.     d=pn->v_num;  
  65.     pqu->front=pn->next;  
  66.     free(pn);  
  67.     return d;  
  68. }  
  69. int locate(graph g, DataType data)  
  70. {  
  71.     int i;  
  72.     for(i=0;i<g.vexnum;i++)  
  73.         if(g.vexs[i] == data)  
  74.             return i;  
  75.      return -1;  
  76. }  
  77. graph create_graph()  
  78. {  
  79.     int i,j,w, s1,s2;  
  80.     DataType ch1,ch2,tmp;  
  81.     graph g;  
  82.     printf("g sizeof: %d/n", sizeof(g));  
  83.     printf("Enter vexnum arcnum:");  
  84.     scanf("%d %d", &g.vexnum, &g.arcnum);  
  85.     tmp=getchar();  
  86.     g.vexs=(DataType *)malloc(sizeof(DataType));  
  87.     if(g.vexs == NULL)  
  88.         exit(1);  
  89.     printf("Enter %d vertext,please.../n", g.vexnum);  
  90.     for(i=0;i<g.vexnum;i++)  
  91.     {  
  92.         printf("vex %d: ", i);  
  93.         scanf("%c", &g.vexs[i]);  
  94.         tmp=getchar();  
  95.         //visited[i]=0;  
  96.     }  
  97.     for(i=0;i<g.vexnum;i++)  
  98.         for(j=0;j<g.vexnum;j++)  
  99.             g.arcs[i][j]=INFINITY;  
  100.      printf("Enter %d arcs:/n", g.arcnum);  
  101.      for(i=0;i<g.arcnum;i++)  
  102.      {  
  103.         printf("arc %d: ", i);  
  104.         scanf("%c %c %d", &ch1, &ch2, &w);  
  105.         tmp=getchar();  
  106.         s1=locate(g, ch1);  
  107.         s2=locate(g, ch2);  
  108.         g.arcs[s1][s2]=g.arcs[s2][s1]=w; /* NOTE: weight */  
  109.      }  
  110.      return g;  
  111. }  
  112. int firstvex_graph(graph g, int k)  
  113. {  
  114.     int i;  
  115.     if(k>=0 && k<g.vexnum)  
  116.         for(i=0;i<g.vexnum;i++)  
  117.             if(g.arcs[k][i] != INFINITY)  
  118.                 return i;  
  119.      return -1;  
  120. }  
  121. int nextvex_graph(graph g, int i, int j)  
  122. {  
  123.     int k;  
  124.     if(i>=0 && i<g.vexnum && j>=0 && j<g.vexnum)  
  125.         for(k=j+1; k<g.vexnum; k++)  
  126.             if(g.arcs[i][k] != INFINITY)  
  127.                 return k;  
  128.      return -1;  
  129. }  
  130. void dfs(graph g, int k)  
  131. {  
  132.     int i;  
  133.     if(k == -1)  
  134.     {  
  135.         for(i=0;i<g.vexnum;i++)  
  136.             if(!visited[i])  
  137.                 dfs(g,i);  
  138.      }  
  139.      else  
  140.      {  
  141.         visited[k]=1;  
  142.         printf("%c ", g.vexs[k]);  
  143.         for(i=firstvex_graph(g,k);i>=0;i=nextvex_graph(g,k,i))  
  144.             if(!visited[i])  
  145.                 dfs(g,i);  
  146.      }  
  147. }  
  148. void bfs(graph g)  
  149. {  
  150.     int i,j,k;  
  151.     queue qu;  
  152.     qu=init_queue();  
  153.     for(i=0;i<g.vexnum;i++)  
  154.         if(!visited[i])  
  155.         {  
  156.             visited[i] =1;  
  157.             printf("%c ", g.vexs[i]);  
  158.             en_queue(&qu, i);  
  159.             while(!isempty_queue(&qu))  
  160.             {  
  161.                 k=de_queue(&qu);  
  162.                 for(j=firstvex_graph(g,k); j>=0;j=nextvex_graph(g,k,j))  
  163.                     if(!visited[j])  
  164.                     {  
  165.                         visited[j]=1;  
  166.                         printf("%c ", g.vexs[j]);  
  167.                         en_queue(&qu, j);  
  168.                     }  
  169.             }  
  170.         }  
  171. }  
  172. void main()  
  173. {  
  174.     int i;  
  175.     graph g;  
  176.     g=create_graph();  
  177.     visited=(int *)malloc(g.vexnum*sizeof(int));  
  178.     for(i=0;i<g.vexnum;i++)  
  179.         visited[i]=0;  
  180.     printf("/n/n dfs:");  
  181.     dfs(g,-1);  
  182.     for(i=0;i<g.vexnum;i++)  
  183.         visited[i]=0;  
  184.     printf("/n bfs:");  
  185.     bfs(g);  
  186.       
  187.     if(visited)  
  188.         free(visited);  
  189.     printf("/n");  
  190. }  

运行结果：

各种基本算法实现小结（四）—— 图及其遍历_第1张图片     各种基本算法实现小结（四）—— 图及其遍历_第2张图片

======================================================

图——深度优先

测试环境：VS2008 (C)

[cpp]  view plain  copy
 print ?
  1. #include "stdafx.h"  
  2. #include <stdlib.h>  
  3. #include <malloc.h>  
  4. #define MAX_VEX 20  
  5. #define INFINITY 65535  
  6. int *visited;  
  7. struct _node  
  8. {  
  9.     int vex_num;  
  10.     struct _node *next;  
  11. };  
  12. typedef struct _node node, *pnode;  
  13. struct _graph  
  14. {  
  15.     char *vexs;  
  16.     int arcs[MAX_VEX][MAX_VEX];  
  17.     int vexnum, arcnum;  
  18. };  
  19. typedef struct _graph graph, *pgraph;  
  20. int locate(graph g, char ch)  
  21. {  
  22.     int i;  
  23.     for(i=1; i<=g.vexnum; i++)  
  24.         if(g.vexs[i]==ch)  
  25.             return i;  
  26.     return -1;  
  27. }  
  28. graph create_graph()  
  29. {  
  30.     int i, j, w, p1, p2;  
  31.     char ch1, ch2;  
  32.     graph g;  
  33.     printf("Enter vexnum arcnum: ");  
  34.     scanf("%d %d", &g.vexnum, &g.arcnum);  
  35.     getchar();  
  36.     for(i=1; i<=g.vexnum; i++)  
  37.         for(j=1; j<g.vexnum; j++)  
  38.             g.arcs[i][j]=INFINITY;  
  39.     g.vexs=(char *)malloc(sizeof(char));  
  40.     printf("Enter %d vexnum.../n", g.vexnum);  
  41.     for(i=1; i<=g.vexnum; i++)  
  42.     {  
  43.         printf("vex %d: ", i);  
  44.         scanf("%c", &g.vexs[i]);  
  45.         getchar();  
  46.     }  
  47.     printf("Enter %d arcnum.../n", g.arcnum);  
  48.     for(i=1; i<=g.arcnum; i++)  
  49.     {  
  50.         printf("arc %d: ", i);  
  51.         scanf("%c %c %d", &ch1, &ch2, &w);  
  52.         getchar();  
  53.         p1=locate(g, ch1);  
  54.         p2=locate(g, ch2);  
  55.         g.arcs[p1][p2]=g.arcs[p2][p1]=w;  
  56.     }  
  57.     return g;  
  58. }  
  59. int firstvex_graph(graph g, int i)  
  60. {  
  61.     int k;  
  62.     if(i>=1 && i<=g.vexnum)  
  63.         for(k=1; k<=g.vexnum; k++)  
  64.             if(g.arcs[i][k]!=INFINITY)  
  65.                 return k;  
  66.     return -1;  
  67. }  
  68. int nextvex_graph(graph g, int i, int j)  
  69. {  
  70.     int k;  
  71.     if(i>=1 && i<=g.vexnum && j>=1 && j<=g.vexnum)  
  72.         for(k=j+1; k<=g.vexnum; k++)  
  73.             if(g.arcs[i][k]!=INFINITY)  
  74.                 return k;  
  75.     return -1;  
  76. }  
  77. void dfs(graph g, int i)  
  78. {  
  79.     int k, j;  
  80.     if(!visited[i])  
  81.     {  
  82.         visited[i]=1;  
  83.         printf("%c", g.vexs[i]);  
  84.         for(j=firstvex_graph(g, i); j>=1; j=nextvex_graph(g, i, j))  
  85.             if(!visited[j])  
  86.                 dfs(g, j);  
  87.     }  
  88. }  
  89. void dfs_graph(graph g)  
  90. {  
  91.     int i;  
  92.     visited=(int *)malloc((g.vexnum+1)*sizeof(int));  
  93.     for(i=1; i<=g.vexnum; i++)  
  94.         visited[i]=0;  
  95.     for(i=1; i<g.vexnum; i++)  
  96.         if(!visited[i])  
  97.             dfs(g, i);  
  98. }  
  99. int _tmain(int argc, _TCHAR* argv[])  
  100. {  
  101.     graph g;  
  102.     g=create_graph();  
  103.     dfs_graph(g);  
  104.     printf("/n");  
  105.     return 0;  
  106. }  

======================================================

图——广度优先

测试环境：VS2008 (C)

[cpp] view plain copy
 print ?
  1. #include "stdafx.h"  
  2. #include <stdlib.h>  
  3. #include <malloc.h>  
  4. #define MAX_VEX 20  
  5. #define INFINITY 65535  
  6. int *visited;  
  7. struct _node  
  8. {  
  9.     int data;  
  10.     struct _node *next;  
  11. };  
  12. typedef struct _node node, *pnode;  
  13. struct _queue  
  14. {  
  15.     pnode front;  
  16.     pnode rear;  
  17. };  
  18. typedef struct _queue queue, *pqueue;  
  19. queue init_queue()  
  20. {  
  21.     pnode pn=NULL;  
  22.     queue qu;  
  23.     pn=(pnode)malloc(sizeof(node));  
  24.     if(pn==NULL)  
  25.         printf("init queue, malloc is fail.../n");  
  26.     pn->data=-1;  
  27.     pn->next=NULL;  
  28.     qu.front=qu.rear=pn;  
  29.     return qu;  
  30. }  
  31. int empty_queue(queue qu)  
  32. {  
  33.     if(qu.rear==qu.front)  
  34.         return 0;  
  35.     else  
  36.         return 1;  
  37. }  
  38. void en_queue(pqueue pqu, int data)  
  39. {  
  40.     pnode pn=NULL;  
  41.     if(pqu->rear==NULL)  
  42.         return;  
  43.     pn=(pnode)malloc(sizeof(node));  
  44.     pn->data=data;  
  45.     pn->next=pqu->rear->next;  
  46.     pqu->rear->next=pn;  
  47.     pqu->rear=pn;  
  48. }  
  49. int de_queue(pqueue pqu)  
  50. {  
  51.     int data;  
  52.     pnode pn=NULL;  
  53.     if(pqu->front->next==NULL)  
  54.         return -1;  
  55.       
  56.     pn=pqu->front->next;  
  57.     pqu->front=pqu->front->next;  
  58.     data=pn->data;  
  59.     free(pn);  
  60.     return data;  
  61. }  
  62. struct _graph  
  63. {  
  64.     char *vexs;  
  65.     int arcs[MAX_VEX][MAX_VEX];  
  66.     int vexnum, arcnum;  
  67. };  
  68. typedef _graph graph, *pgraph;  
  69. int locate(graph g, char ch)  
  70. {  
  71.     int i;  
  72.     for(i=1; i<=g.vexnum; i++)  
  73.         if(g.vexs[i]==ch)  
  74.             return i;  
  75.     return -1;  
  76. }  
  77. graph create_graph()  
  78. {  
  79.     int i, j, w, p1, p2;  
  80.     char ch1, ch2;  
  81.     graph g;  
  82.     printf("Enter vexnum arcnum: ");  
  83.     scanf("%d %d", &g.vexnum, &g.arcnum);  
  84.     getchar();  
  85.     for(i=1; i<=g.vexnum; i++)  
  86.         for(j=1; j<g.vexnum; j++)  
  87.             g.arcs[i][j]=INFINITY;  
  88.     g.vexs=(char *)malloc((g.vexnum+1)*sizeof(char));  
  89.     printf("Enter %d vexnum.../n", g.vexnum);  
  90.     for(i=1; i<=g.vexnum; i++)  
  91.     {  
  92.         printf("vex %d: ", i);  
  93.         scanf("%c", &g.vexs[i]);  
  94.         getchar();  
  95.     }  
  96.     printf("Enter %d arcnum.../n", g.arcnum);  
  97.     for(i=1; i<=g.arcnum; i++)  
  98.     {  
  99.         printf("arc %d: ", i);  
  100.         scanf("%c %c %d", &ch1, &ch2, &w);  
  101.         getchar();  
  102.         p1=locate(g, ch1);  
  103.         p2=locate(g, ch2);  
  104.         g.arcs[p1][p2]=g.arcs[p2][p1]=w;  
  105.     }  
  106.     return g;  
  107. }  
  108. int firstvex_graph(graph g, int i)  
  109. {  
  110.     int k;  
  111.     if(i>=1 && i<=g.vexnum)  
  112.         for(k=1; k<=g.vexnum; k++)  
  113.             if(g.arcs[i][k]!=INFINITY)  
  114.                 return k;  
  115.     return -1;  
  116. }  
  117. int nextvex_graph(graph g, int i, int j)  
  118. {  
  119.     int k;  
  120.     if(i>=1 && i<=g.vexnum && j>=1 && j<=g.vexnum)  
  121.         for(k=j+1; k<=g.vexnum; k++)  
  122.             if(g.arcs[i][k]!=INFINITY)  
  123.                 return k;  
  124.     return -1;  
  125. }  
  126. void bfs(graph g)  
  127. {  
  128.     int i, ivex, inextvex;  
  129.     visited=(int *)malloc((g.vexnum+1)*sizeof(int));  
  130.     for(i=1; i<=g.vexnum; i++)  
  131.         visited[i]=0;  
  132.     queue qu=init_queue();  
  133.     for(i=1; i<=g.vexnum; i++)  
  134.     {  
  135.         if(!visited[i])  
  136.         {  
  137.             visited[i]=1;  
  138.             printf("%c", g.vexs[i]);  
  139.             en_queue(&qu, i);  
  140.         }  
  141.           
  142.         while(!empty_queue(qu))  
  143.         {  
  144.             ivex=de_queue(&qu);  
  145.             for(inextvex=firstvex_graph(g, ivex); inextvex>=1; inextvex=nextvex_graph(g, ivex, inextvex))  
  146.                 if(!visited[inextvex])  
  147.                 {  
  148.                     visited[inextvex]=1;  
  149.                     printf("%c", g.vexs[inextvex]);  
  150.                     en_queue(&qu, inextvex);  
  151.                 }  
  152.         }  
  153.     }  
  154. }  
  155. int _tmain(int argc, _TCHAR* argv[])  
  156. {  
  157.     graph g;  
  158.     g=create_graph();  
  159.     bfs(g);  
  160.     printf("/n");  
  161.     return 0;  
  162. }  

======================================================

 

图——深度优先和广度优先算法2（网摘）

本文引用网址：http://bbs.bccn.net/thread-155311-1-1.html（编程论坛）

看到本算法在网上转载较多，比较流行，且能直接运行

但发现大多转载中，也把DFS与BFS正好写反了，对此本文已修正

此外，本算法混用了C与C++，不够单纯，申请的指针空间也未及时释放

 

测试环境：VC 6.0 (C)

[cpp]  view plain  copy
 print ?
  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3. #define INFINITY 32767  
  4. #define MAX_VEX 20   
  5. #define QUEUE_SIZE (MAX_VEX+1)   
  6. bool *visited;    
  7. typedef struct  
  8. {  
  9.     char *vexs;                    //顶点向量  
  10.     int arcs[MAX_VEX][MAX_VEX];    //邻接矩阵  
  11.     int vexnum,arcnum;             //图的当前顶点数和弧数  
  12. }Graph;  
  13. //队列类  
  14. class Queue  
  15. {  
  16.     public:  
  17.     void InitQueue(){  
  18.     base=(int *)malloc(QUEUE_SIZE*sizeof(int));  
  19.     front=rear=0;  
  20. }  
  21. void EnQueue(int e)  
  22. {  
  23.     base[rear]=e;  
  24.     rear=(rear+1)%QUEUE_SIZE;  
  25. }  
  26. void DeQueue(int &e)  
  27. {  
  28.     e=base[front];  
  29.     front=(front+1)%QUEUE_SIZE;  
  30. }  
  31. public:  
  32.     int *base;  
  33.     int front;  
  34.     int rear;  
  35. };  
  36. //图G中查找元素c的位置  
  37. int Locate(Graph G,char c)  
  38. {  
  39.     for(int i=0;i<G.vexnum;i++)  
  40.         if(G.vexs[i]==c)   
  41.             return i;  
  42.       
  43.     return -1;  
  44. }  
  45. //创建无向网  
  46. void CreateUDN(Graph &G){  
  47.     int i,j,w,s1,s2;  
  48.     char a,b,temp;  
  49.     printf("输入顶点数和弧数: ");  
  50.     scanf("%d%d",&G.vexnum,&G.arcnum);  
  51.     temp=getchar(); //接收回车  
  52.     G.vexs=(char *)malloc(G.vexnum*sizeof(char)); //分配顶点数目  
  53.     printf("输入%d个顶点./n",G.vexnum);  
  54.     for(i=0;i<G.vexnum;i++) //初始化顶点  
  55.     {   
  56.         printf("输入顶点%d: ",i);  
  57.         scanf("%c",&G.vexs[i]);  
  58.         temp=getchar(); //接收回车   
  59.     }  
  60.     for(i=0;i<G.vexnum;i++) //初始化邻接矩阵  
  61.         for(j=0;j<G.vexnum;j++)  
  62.             G.arcs[i][j]=INFINITY;  
  63.     printf("输入%d条弧./n",G.arcnum);  
  64.     for(i=0;i<G.arcnum;i++)  
  65.     { //初始化弧  
  66.         printf("输入弧%d: ",i);  
  67.         scanf("%c %c %d",&a,&b,&w); //输入一条边依附的顶点和权值  
  68.         temp=getchar(); //接收回车  
  69.         s1=Locate(G,a);  
  70.         s2=Locate(G,b);  
  71.         G.arcs[s1][s2]=G.arcs[s2][s1]=w;  
  72.     }  
  73. }  
  74. //图G中顶点k的第一个邻接顶点  
  75. int FirstVex(Graph G,int k)  
  76. {  
  77.     if(k>=0 && k<G.vexnum) //k合理  
  78.         for(int i=0;i<G.vexnum;i++)  
  79.             if(G.arcs[k][i]!=INFINITY) return i;  
  80.   return -1;  
  81. }  
  82. //图G中顶点i的第j个邻接顶点的下一个邻接顶点  
  83. int NextVex(Graph G,int i,int j)  
  84. {  
  85.     if(i>=0 && i<G.vexnum && j>=0 && j<G.vexnum) //i,j合理  
  86.         for(int k=j+1;k<G.vexnum;k++)  
  87.             if(G.arcs[i][k]!=INFINITY)   
  88.                 return k;  
  89.   return -1;  
  90. }  
  91. //深度优先遍历  
  92. void DFS(Graph G,int k)  
  93. {  
  94.     int i;  
  95.     if(k==-1) //第一次执行DFS时,k为-1  
  96.     {  
  97.         for(i=0;i<G.vexnum;i++)  
  98.             if(!visited[i])   
  99.                 DFS(G,i); //对尚未访问的顶点调用DFS  
  100.     }  
  101.     else  
  102.     {   
  103.         visited[k]=true;  
  104.         printf("%c ",G.vexs[k]); //访问第k个顶点  
  105.         for(i=FirstVex(G,k);i>=0;i=NextVex(G,k,i))  
  106.             if(!visited[i]) //对k的尚未访问的邻接顶点i递归调用DFS  
  107.                 DFS(G,i);   
  108.     }  
  109. }  
  110. //广度优先遍历  
  111. void BFS(Graph G)  
  112. {  
  113.     int k;  
  114.     Queue Q; //辅助队列Q  
  115.     Q.InitQueue();  
  116.     for(int i=0;i<G.vexnum;i++)  
  117.         if(!visited[i]) //i尚未访问  
  118.         {   
  119.             visited[i]=true;  
  120.             printf("%c ",G.vexs[i]);  
  121.              Q.EnQueue(i); //i入列  
  122.             while(Q.front!=Q.rear)  
  123.             {  
  124.                 Q.DeQueue(k); //队头元素出列并置为k  
  125.                 for(int w=FirstVex(G,k);w>=0;w=NextVex(G,k,w))  
  126.                     if(!visited[w]) //w为k的尚未访问的邻接顶点  
  127.                     {   
  128.                         visited[w]=true;  
  129.                         printf("%c ",G.vexs[w]);  
  130.                         Q.EnQueue(w);  
  131.                     }  
  132.             }  
  133.         }  
  134. }  
  135. //主函数  
  136. void main(){  
  137.     int i;  
  138.     Graph G;  
  139.     CreateUDN(G);  
  140.     visited=(bool *)malloc(G.vexnum*sizeof(bool));   
  141.     printf("/n深度优先遍历: ");   
  142.     for(i=0;i<G.vexnum;i++)  
  143.         visited[i]=false;  
  144.     DFS(G,-1); /* NODE: DFS */  
  145.     printf("/n广度优先遍历: ");   
  146.     for(i=0;i<G.vexnum;i++)  
  147.         visited[i]=false;  
  148.     BFS(G); /* NODE: BFS */  
  149.     printf("/n程序结束./n");  
  150. }  

运行结果：

各种基本算法实现小结（四）—— 图及其遍历_第3张图片    各种基本算法实现小结（四）—— 图及其遍历_第4张图片

======================================================

 

[cpp]  view plain  copy
 print ?
  1. #include <iostream.h>   
  2. #include <stdlib.h>   
  3. #define INFINITY 0   
  4. #define MAX_VERTEX_NUM 10 //最大顶点数   
  5. #define MAX_EDGE_NUM 40 //最大边数   
  6. typedef enum {DG,DN,UDG,UDN}Graphkind;   
  7. typedef char VertexType; //顶点数据类型   
  8. typedef struct ArcCell   
  9. {   
  10. int adj; //无权图，1或0表示相邻否；带权图则是权值。   
  11. //int *info;   
  12. }ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];   
  13. typedef struct   
  14. {   
  15. VertexType vexs[MAX_VERTEX_NUM]; //顶点向量   
  16. AdjMatrix arcs; //邻接矩阵   
  17. int vexnum,arcnum; //图的当前顶点数和弧数。   
  18. Graphkind kind;   
  19. }MGraph;   
  20. int LocateVex(MGraph G,VertexType v1)   
  21. {   
  22. int i;   
  23. for(i=0;i<G.vexnum;i++)   
  24. if(G.vexs[i]==v1)   
  25. return i;   
  26. return -1;   
  27. }   
  28. int CreatUDN(MGraph &G)   
  29. // 采用数组表示法，构造无向网 G   
  30. {   
  31. VertexType v1,v2;   
  32. int w,j;   
  33. cout<<"输入图的顶点数"<<endl;   
  34. cin>>G.vexnum;   
  35. cout<<"输入图的弧数"<<endl;   
  36. cin>>G.arcnum;   
  37. for(int i=0;i<G.vexnum;i++)   
  38. {   
  39. cout<<"输入顶点向量"<<endl;   
  40. cin>>G.vexs[i];   
  41. }   
  42. for(i=0;i<G.vexnum;i++)   
  43. for(j=0;j<G.vexnum;j++)   
  44. {   
  45. G.arcs[i][j].adj=INFINITY;   
  46. }   
  47. for(int k=0;k<G.arcnum;++k) //构造邻接矩阵   
  48. {   
  49. cout<<"输入边依附的两个顶点"<<endl;   
  50. cin>>v1>>v2;   
  51. cout<<"输入此边的权值"<<endl;   
  52. cin>>w;   
  53. i=LocateVex(G,v1);   
  54. j=LocateVex(G,v2);   
  55. G.arcs[i][j].adj=w;   
  56. G.arcs[j][i].adj=G.arcs[i][j].adj;   
  57. }   
  58. return 1;   
  59. }   
  60. void dispMGraph(MGraph G)   
  61. {   
  62. cout<<"图的邻接矩阵图是："<<endl;   
  63. for(int i=0;i<G.vexnum;i++)   
  64. {   
  65. for(int j=0;j<G.vexnum;j++)   
  66. cout<<" "<<G.arcs[i][j].adj;   
  67. cout<<endl;   
  68. }   
  69. }   
  70. void main()   
  71. {   
  72. MGraph G;   
  73. CreatUDN(G);   
  74. dispMGraph(G);   
  75. }   
  76. // 邻接表 表示:   
  77. #include <iostream.h>   
  78. #include <stdlib.h>   
  79. #define MAX_VERTEX_NUM 20 //最大顶点数   
  80. #define MAX_EDGE_NUM 40 //最大边数   
  81. int visited[ MAX_VERTEX_NUM];   
  82. typedef int VertexType ; //顶点数据类型   
  83. typedef struct ArcNode   
  84. {   
  85. int adjvex;   
  86. int weight;   
  87. struct ArcNode *nextarc;   
  88. }ArcNode;   
  89. typedef struct VNode   
  90. {   
  91. VertexType data;   
  92. ArcNode *firstarc;   
  93. }VNode,AdjList[MAX_VERTEX_NUM];   
  94. typedef struct   
  95. {   
  96. AdjList vertices;   
  97. int vexnum,arcnum;   
  98. int kind;   
  99. }ALGraph;   
  100. void CreateDG(ALGraph &G)   
  101. {   
  102. int i,j,k;   
  103. ArcNode *p;   
  104. cout<<"创建一个图:"<<endl;   
  105. cout<<"顶点数:"; cin>>G.vexnum;cout<<endl;   
  106. cout<<"边数:"; cin>>G.arcnum; cout<<endl;   
  107. for(i=0;i<G.vexnum;i++)   
  108. {   
  109. G.vertices[i].data=i;   
  110. G.vertices[i].firstarc=NULL;   
  111. }   
  112. for(k=0;k<G.arcnum;k++)   
  113. {   
  114. cout<<"请输入第"<<k+1<<"条边:";   
  115. cin>>i>>j;   
  116. p=(ArcNode*)malloc(sizeof(ArcNode));   
  117. p->adjvex=j;   
  118. p->nextarc=G.vertices[i].firstarc;   
  119. G.vertices[i].firstarc=p;   
  120. }   
  121. }   
  122. void Disp(ALGraph G)   
  123. {   
  124. int i,j;   
  125. ArcNode *p;   
  126. cout<<"输出图为:"<<endl;   
  127. for(i=0;i<G.vexnum;i++)   
  128. {   
  129. p=G.vertices[i].firstarc;   
  130. j=0;   
  131. while(p!=NULL)   
  132. {   
  133. cout<<"("<<i<<","<<p->adjvex<<")";   
  134. p=p->nextarc;   
  135. j=1;   
  136. }   
  137. if(j==1)   
  138. cout<<endl;   
  139. }   
  140. }   
  141. void dfs(ALGraph G,int v) //深度优先遍历   
  142. {   
  143. ArcNode *p;   
  144. cout<<v<<" ";   
  145. visited[v]=1;   
  146. p=G.vertices[v].firstarc;   
  147. while(p!=NULL)   
  148. { if(!visited[p->adjvex])   
  149. dfs(G,p->adjvex);   
  150. p=p->nextarc;   
  151. }   
  152. return ;   
  153. }   
  154. void dfs1(ALGraph G)   
  155. {   
  156. int i;   
  157. for(i=0;i<G.vexnum;i++)   
  158. if(visited[i]==0)   
  159. dfs(G,i);   
  160. }   
  161. void main()   
  162. {   
  163. ALGraph G;   
  164. CreateDG(G);   
  165. int v;   
  166. Disp(G);   
  167. cout<<"输入顶点:";   
  168. cin>>v;   
  169. cout<<"深度优先序列:";   
  170. dfs1(G);   
  171. cout<<endl;   
  172. }   


参考推荐：

学习算法之路

各种基本算法实现小结（一）—— 链 表

各种基本算法实现小结（二）—— 堆 栈

各种基本算法实现小结（三）—— 树与二叉树

各种基本算法实现小结（四）—— 图及其遍历

各种基本算法实现小结（五）—— 排序算法

各种基本算法实现小结（六）—— 查找算法

各种基本算法实现小结（七）—— 常用算法


12个有趣的C语言面试题

作者原文地址：http://blog.csdn.net/sunboy_2050/article/details/5645828

你可能感兴趣的:(数据结构,算法,C语言,图)

  • ECharts 柱状图X轴或Y轴空值无数据不占位不渲染不展示 大橙子- echarts前端javascript
    效果查看：将option复制到echarts解析垂直方向：//垂直方向代码示例option={legend:{//这里data省略echarts会自动匹配，也可自行配置},xAxis:[//关键点：多个X轴进行匹配{type:'category',position:'bottom',data:['2021','']//空字符串则不会展示},{type:'category',position:'bo
  • 设计模式-模板方法实现 阿绵 设计模式java开发语言
    文章目录模式结构模式特点示例代码输出结果关键点解析模式的优缺点使用场景总结模板方法模式（TemplateMethodPattern）是一种行为型设计模式，它定义了一个操作中的算法骨架，而将某些步骤的实现延迟到子类中。通过这种方式，模板方法模式可以让子类在不改变算法结构的情况下，重新定义算法中的某些步骤模式结构模板方法模式的结构包括以下几个关键部分：抽象类（AbstractClass）：定义算法的骨
  • 数据库基础以及 MySQL 知识点 阿绵 计算机基础数据库mysql
    文章目录1、基本概念2、主键和外键的区别2.1、使用外键的优劣3、数据库范式4、drop、delete与truncate区别？5、MySQL1、基础概念2、存储引擎2.1、InnoDB和MyISAM区别2.2、InnoDB如何保持事务的四大特性（实现事务的原理）3、锁机制与InnoDB锁算法3.1、表级锁和行级锁对比4、事务4.1、ACID特性4.2、并发事务带来的问题4.3、事务隔离级别1、基本
  • Python 队列的使用：掌握先进先出的数据结构 车载testing python
    Python队列的使用：掌握先进先出的数据结构队列是一种先进先出（FIFO）的数据结构，它在多种编程场景中都非常有用，比如任务调度、事件处理等。在Python中，我们可以通过标准库中的queue模块来实现队列。本文将详细介绍如何使用Python的queue模块来创建和操作队列。导入Queue模块使用queue模块之前，我们需要先导入它：fromqueueimportQueue创建队列创建一个队列实
  • yolov8人脸识别与脸部关键点检测（代码+原理） QQ_1309399183 计算机视觉实战项目集锦YOLO人工智能人脸识别yolo人脸检测
    YOLOv8脸部识别是一个基于YOLOv8算法的人脸检测项目，旨在实现快速、准确地检测图像和视频中的人脸。该项目是对YOLOv8算法的扩展和优化，专门用于人脸检测任务。YOLOv8是一种基于深度学习的目标检测算法，通过将目标检测问题转化为一个回归问题，可以实现实时的目标检测。YOLOv8Face项目在YOLOv8的基础上进行了改进，使其更加适用于人脸检测。以下是YOLOv8Face项目的一些特点和
  • 基于Python的搜索引擎的设计与实现 AI大模型应用之禅 DeepSeekR1&AI大模型与大数据javapythonjavascriptkotlingolang架构人工智能
    搜索引擎,Python,爬虫,自然语言处理,信息检索,索引,算法,数据库1.背景介绍在信息爆炸的时代，海量数据无处不在，高效地获取所需信息变得至关重要。搜索引擎作为信息获取的桥梁，扮演着不可或缺的角色。传统的搜索引擎往往依赖于庞大的服务器集群和复杂的算法，对资源消耗较大，且难以满足个性化搜索需求。基于Python的搜索引擎设计，则凭借Python语言的易学易用、丰富的第三方库和强大的社区支持，为开
  • java中类似sort_java中的Sort函数，你值得看 weixin_39928844 java中类似sort
    基于C语言中的sort如此这么方便，自然而然，java中也有类似C的sort函数。1.普通数组：Arrays.sort(数组名，开始位置，结束位置)。2.类中属性排序：模板：classA{intn;}classcmpimplementComparator{升序：publicintcompare(Aa,Ab){if(a.n
  • 27岁大龄转码秋招惨败，朋友劝我转Java来得及吗？还是继续走前端或机器学习？ 程序员yt java机器学习开发语言
    今天给大家分享的是一位粉丝的提问，27岁大龄转码秋招惨败，朋友劝我转Java来得及吗？还是继续走前端或机器学习？接下来把粉丝的具体提问和我的回复分享给大家，希望也能给一些类似情况的小伙伴一些启发和帮助。同学提问：211建筑本科，22年毕业后gap一年转码去了英国读的QS100的it的水硕（24年12月份毕业），转码后对就业形势认知不足，时间全花在课业上，八股文和算法准备的不充足，秋招算是惨败。读研
  • c语言笔试题总结 o0o0o0D 笔试题c语言
    1、局部变量能否和全局变量重名？答：能，局部会屏蔽全局。要用全局变量，需要使用"::";局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。2、如何引用一个已经定义过的全局变量？答：extern可以用引用头文件的
  • 分布式理论与分布式算法 红衣女妖仙 springcloud分布式分布式定理分布式算法
      分布式定义、主要目标、优缺点、与集中式区别；分布式CAP定理、PACELC理论、BASE理论的核心观点、应用场景等；分布式算法如Paxos算法、Raft算法、Gossip算法、两阶段提交（2PC）、三阶段提交（3PC）、一致性哈希算法、Bully算法、Chord算法等算法的核心思想、角色、算法过程、特性、应用场景和变种等。——2025年2月3日甲辰年正月初六立春目录1分布式1.1分布式定义1.
  • iOS Blocks与Dispatch Queue的使用 a14776584 IOSBlocksDispatchQueuedispatch_asynciosiOSIOS
    转载自http://liwpk.blog.163.com/blog/static/363261702012413103111749/block是什么block是一个Clevel的语法以及运行时的一个特性，和标准C中的函数（函数指针）类似。用于回调函数的地方。两个对象间的通讯。实现轻量级的“代理”。blocks和C语言函数指针的区别如何调用blocks调用block和C语言函数指针的调用一模一样如何
  • 华为的云端训练算力与迭代效率 AI大模型应用之禅 DeepSeekR1&AI大模型与大数据计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    华为云、云端训练、算力、迭代效率、人工智能、深度学习、模型训练、分布式训练、优化算法1.背景介绍人工智能（AI）技术近年来发展迅速，深度学习作为其核心驱动力，在图像识别、自然语言处理、语音识别等领域取得了突破性进展。然而，深度学习模型的训练需要海量数据和强大的计算资源，这成为AI技术发展面临的瓶颈之一。云计算作为一种新型的计算模式，为深度学习提供了强大的算力支持。华为云作为国内领先的云计算平台，在
  • SpringCloud微服务架构之断路器，如何解决微服务中的雪崩效应？ 2401_89225002 架构微服务springcloud
    图3.2极端情况下的微服务网状调用示意图最常见的场景就是当负载过高时，如果某个服务的性能或抗压能力不好，那么当请求到这个服务时就需要等待或直接出现超时、不可用等情况。在图3.2中，一旦服务C出现问题，可能会影响服务A和服务B，虽然服务D、E、F并没有直接与服务C相互依赖，但是服务C导致了服务A和服务B的阻塞，就会间接地影响服务D、E、F，从而让整个系统变得缓慢或不可用，这就是微服务的雪崩效应。微服
  • SaaS的多租户数据隔离有哪几种？ 衫恋冰 数据库
    saas多租户系统总结下来基本有三种数据隔离方案，分别是：1、物理数据库隔离2、单数据库表空间隔离3、单表内租户id字段隔离三种方案的对比图如下：隔离方案成本安全优点缺点物理数据库隔离高高数据隔离级别高，而且也可以针对租户开发个性化需求，而且也可以支持更大的数据量。支持的租户数量较少，同时数据库独立安装带来的运维成本比较高物理数据库隔离中中一个数据库可支撑多个租户，同时成本也相对较低，而且也有一定
  • 无人设备遥控器之视频回传篇 SKYDROID云卓小助手 音视频人工智能计算机视觉网络目标检测嵌入式硬件
    无人设备遥控器的视频回传是指将无人设备（如无人机）采集到的视频信号传输回遥控器或其他接收设备的过程。这一过程在诸多应急情境中显得尤为重要，它能为指挥中心的决策者、调度系统以及AI分析等提供实时画面。一、主流回传方式目前，主流的视频回传方式是利用遥控器的4G/5G上网功能。无人机通过空中的图传系统将影像传输至遥控器，再经由遥控器重新编码后，利用4G/5G网络进行回传。这种方式具有覆盖范围广、传输速度
  • 通过nginx对arcgispro生成的矢量瓦片发布并调用（干货） 蓝布城发动机 nginxarcgis
    一、矢量瓦片的制作与发布试验采用国土调查的土地利用现状的数据，制作的矢量瓦片的流程如图所示：图1矢量瓦片数据生产流程数据生产分为两个步骤：1、数据配图先在ArcMap软件中建立好工程并配图，土地利用现状的配图样式按照《规程》设计的土地利用符号保存为style文件，在ArcMap加载土地利用数据后，通过数据中DLBM字段与符号库做样式匹配，并保存为MXD格式工程。打开ArcgisPro新建工程，导入
  • 力扣hot100——42.接雨水 码凡 leetcode算法
    42.接雨水给定n个非负整数表示每个宽度为1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。示例1：输入：height=[0,1,0,2,1,0,1,3,2,1,2,1]输出：6解释：上面是由数组[0,1,0,2,1,0,1,3,2,1,2,1]表示的高度图，在这种情况下，可以接6个单位的雨水（蓝色部分表示雨水）。示例2：输入：height=[4,2,0,3,2,5]输出：9提示：n==
  • 【深度学习】学习率调度策略 黑白交界 深度学习学习深度学习
    什么是学习率可以理解为模型在每一次迭代中的模型更新调整的幅度，“学习”新信息的速度。学习率定义了模型权重（参数）在梯度下降或其他优化算法中的更新步伐。较大的学习率意味着在每次参数更新时，模型会进行更大幅度的调整，而较小的学习率则意味着细致的、渐进的调整。适当的学习率可以帮助模型跳出局部最优解。当使用较大的学习率时，模型有可能跨越一些小的局部最优，从而找到全局最优解，但也有可能错过全局最优。因此，在
  • 深入理解Java的集合框架 一碗黄焖鸡三碗米饭 java
    深入理解Java的集合框架Java集合框架（JavaCollectionsFramework，简称JCF）是Java语言中最常用的API之一，它为开发者提供了强大且灵活的数据结构支持。集合框架通过一系列的接口和实现类，帮助我们管理、存储和操作数据。Java集合框架包括常见的List、Set、Map等接口及其具体实现类，合理选择适当的集合类型，对于程序性能和代码可维护性至关重要。本文将深入解析Jav
  • 个人简历html网页模板，科技感炫酷html简历模板 孤客网络科技工作室 html+css网页开发html科技前端
    炫酷动效登录页引言在网页设计中，按钮是用户交互的重要元素之一。这样一款黑色个人简历html网页模板，科技感炫酷html简历模板，设计效果类似科技看板图，可帮您展示技能、任职经历、作品等，喜欢这种风格的小伙伴不要犹豫哦。该素材呈现了数据符号排版显示出人形的动画效果，新颖有创意，希望大家能够喜欢。效果预览在开始之前，我们先来看一下最终的效果：实现步骤1.index.html（部分代码）首先，我们需要创
  • 零基础学Python图片处理：用Pillow库轻松玩转修图 小彭爱学习 pythonpythonpillowpython处理图片
    零基础学Python图片处理：用Pillow库轻松玩转修图一、初识Pillow：你的第一张数码暗房安装准备（只需要1分钟）打开电脑的命令行（Windows按Win+R输入cmd，Mac打开终端），输入：pipinstallpillow看到「SuccessfullyinstalledPillow-x.x.x」就安装成功啦！图片处理四步走打开图片：像打开文件柜一样找到图片修改图片：裁剪、调色、加特效查
  • 02.19 构造函数 Unique_yt c++算法开发语言
    1.思维导图2.封装一个mystring类，拥有私有成员：char*pintlen需要让以下代码编译通过，并实现对应功能：mystringstr="hello"；mystringptr;ptr.copy(str);ptr.append(str);ptr.show();输出ptr代表的字符串ptr.compare(str);比较ptr和str是否一样ptr.swap(str);交换ptr和str的内
  • 【核心算法篇七】《DeepSeek异常检测：孤立森林与AutoEncoder对比》 再见孙悟空_ 「2025DeepSeek技术全景实战」算法分布式docker计算机视觉人工智能自然语言处理DeepSeek
    大家好，今天我们来深入探讨一下《DeepSeek异常检测：孤立森林与AutoEncoder对比》这篇技术博客。我们将从核心内容、原理、应用场景等多个方面进行详细解析，力求让大家对这两种异常检测方法有一个全面而深入的理解。一、引言在数据科学和机器学习领域，异常检测（AnomalyDetection）是一个非常重要的任务。它的目标是从数据集中识别出那些与大多数数据显著不同的异常点。这些异常点可能是由于
  • C++ STL容器大全 string vector stack queue list priority_queue set map pair luckyyunji C++数据结构c++
    数据结构(容器)string类Vectorvector向量->不定长数组#include定义vector方法一vectorv1;vector>v2;vector>>v3;方法二vectorv1(5,10);vector>v2(5,vector(5,10));vector>>v3(5,vector(5,vector(5,10)))尾插尾删尾插v.push_back(123);尾删v.pop_back
  • stm32正常运行流程图_stm32初始化流程图解析 imToken-Daisy stm32正常运行流程图
    STM32系列基于专为要求高性能、低成本、低功耗的嵌入式应用专门设计的ARMCortex-M3内核。stm32参数：12V-36V供电兼容5V的I/O管脚优异的安全时钟模式带唤醒功能的低功耗模式内部RC振荡器内嵌复位电路工作温度范围：-40°C至+85°C或105°Cstm32特点：内核：ARM32位Cortex-M3CPU，最高工作频率72MHz，1.25DMIPS/MHz。单周期乘法和硬件除法
  • 【c++】容器：vector、list、map 大姨妈V c++【c++从入门到精通】学习笔记
    【c++】容器1.容器2.顺序容器3.向量4.双向链表5.关联容器6.映射参考：《c++从入门到精通》人民邮电出版社标准模板库STL的c++最有特色、最实用的部分之一。标准模板库包含了容器类、迭代器和算法三部分。容器：容器就是可以用于存放各种类型数据的数据结构。迭代器：迭代器可依次存取容器中的元素，在C++中称迭代器为指针，它们提供了访问容器、序列中每个元素的方法。算法：是用来操作容器中的元素的函
  • 自动化运维工具ansible theo.wu 运维自动化
    Ansible批处理工具Ansible批处理工具功能图Ansible项目架构图一、Ansible介绍1、Ansible简介简介ansible是一种自动化运维工具，基于paramiko模块开发，实现了批量系统配置、批量程序部署、批量运行命令功能。ansible是基于模块工作的，本身没有批量部署的能力。真正具有批量部署的是ansible所运行的模块，ansible只提供一种框架。ansible这个框架
  • STL-vector,set,string,map,queue,priority_queue,stack,pair算法笔记 cloudless_sky STLc++stl
    STL:standardtemplatelibrary标准模板库，封装了很多实用的容器。（一）vectorvector是一个容器。是个类。底层数据结构是数组。vector:向量，变长数组，即“长度根据需要而自动改变的数组”。使用前提：#includeusingnamespacestd;1、vector定义vectorname;以上是长度可以根据需要变化的一位数组，typename可以是任何基本类型
  • 从C语言的角度重构数据结构系列（十三）-位运算 文宇肃然 数据结构常见算法原理讲解C语言数据结构
    位运算简介位运算位运算就是基于整数的二进制表示进行的运算。由于计算机内部就是以二进制来存储数据，位运算是相当快的。基本的位运算共6种，分别为按位与、按位或、按位异或、按位取反、左移和右移。运算运算符数学符号表示解释与&&、and只有两个对应位都为1时才为1或||、or只要两个对应位中有一个1时就为1异或^、xor只有两个对应位不同时才为1左移假设要将一个无符号整数乘以2。可以简单地将所有位向左边移
  • 市面上常见的文件系统及其数据结构和目录结构概述 The god of big data 教程大Big数据Data数据结构java服务器linux云计算openstack
    1.ext4文件系统数据结构：超级块：包含整个文件系统的元信息，如块总数、空闲块数、inode总数等。inode：每个文件或目录都有一个inode，包含文件的元数据，如文件大小、权限、时间戳等。块位图：记录哪些块已被使用，哪些块是空闲的。inode位图：记录哪些inode已被使用，哪些是空闲的。块组：文件系统被划分为多个块组，每个块组包含一组连续的块。目录项：目录文件包含目录项，每个目录项指向一个
  • 多线程编程之卫生间 周凡杨 java并发卫生间线程厕所
    如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
  • How to Install GUI to Centos Minimal sunjing linuxInstallDesktopGUI
    http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html   I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
  • Shell 函数 daizj shell函数
    Shell 函数 linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 shell中函数的定义格式如下： [function] funname [()]{ action; [return int;] } 说明： 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 2、参数返回
  • Linux服务器新手操作之一 周凡杨 Linux 简单 操作
    1.whoami      当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。      此时可以使用whoami命令。      [ecuser@HA5-DZ05 ~]$ whoami       e
  • 浅谈Socket通信（一） 朱辉辉33 socket
    在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。    首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包    ServerSock
  • 关于框架的简单认识 西蜀石兰 框架
    入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。 前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。 后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。 都说学前端的要知道三大框架，目前node.
  • You have an error in your SQL syntax; check the manual that corresponds to your 林鹤霄
    You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids  ) values('0ac91f167f754c8cbac00e9e3dc372
  • MySQL5.6的my.ini配置 aigo mysql
    注意：以下配置的服务器硬件是：8核16G内存    [client]   port=3306   [mysql]   default-character-set=utf8     [mysqld]   port=3306   basedir=D:/mysql-5.6.21-win
  • mysql 全文模糊查找 便捷解决方案 alxw4616 mysql
    mysql 全文模糊查找 便捷解决方案 2013/6/14 by 半仙 [email protected] 目的: 项目需求实现模糊查找. 原则: 查询不能超过 1秒. 问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 解决方案: 使用mysql全文索引. 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
  • 自定义数据结构 链表(单项 ,双向,环形) 百合不是茶 单项链表双向链表
         链表与动态数组的实现方式差不多,    数组适合快速删除某个元素    链表则可以快速的保存数组并且可以是不连续的       单项链表;数据从第一个指向最后一个   实现代码:        //定义动态链表 clas
  • threadLocal实例 bijian1013 javathreadjava多线程threadLocal
    实例1： package com.bijian.thread; public class MyThread extends Thread { private static ThreadLocal tl = new ThreadLocal() { protected synchronized Object initialValue() { return new Inte
  • activemq安全设置—设置admin的用户名和密码 bijian1013 javaactivemq
            ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 <bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint"> <p
  • 【Java范型一】Java范型详解之范型集合和自定义范型类 bit1129 java
    本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。   范型内容 范型集合类 范型类
  • 【HBase十二】HFile存储的是一个列族的数据 bit1129 hbase
    在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证   1. 建立一个有两个列族的表   create 'members','colfam1','colfam2'   2. 在members表中的colfam1中插入50*5
  • Nginx 官方一个配置实例 ronin47 nginx 配置实例
    user www www; worker_processes 5; error_log logs/error.log; pid logs/nginx.pid; worker_rlimit_nofile 8192; events { worker_connections 4096;} http { include conf/mim
  • java-15.输入一颗二元查找树，将该树转换为它的镜像， 即在转换后的二元查找树中，左子树的结点都大于右子树的结点。 用递归和循环 bylijinnan java
    //use recursion public static void mirrorHelp1(Node node){ if(node==null)return; swapChild(node); mirrorHelp1(node.getLeft()); mirrorHelp1(node.getRight()); } //use no recursion bu
  • 返回null还是empty bylijinnan javaapachespring编程
    第一个问题，函数是应当返回null还是长度为0的数组（或集合）？ 第二个问题，函数输入参数不当时，是异常还是返回null？ 先看第一个问题 有两个约定我觉得应当遵守： 1.返回零长度的数组或集合而不是null（详见《Effective Java》） 理由就是，如果返回empty，就可以少了很多not-null判断： List<Person> list
  • [科技与项目]工作流厂商的战略机遇期 comsci 工作流
          在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。         在微软，甲骨文，谷歌，IBM,SONY
  • 过度设计-举例 cuityang 过度设计
    过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。 未来的事情，比如 访问量，比如数据库的容量，比如是否需要改成分布式  都是无法预料的 再举一个例子，对闰年的判断逻辑： 　　1、 if($Year%4==0) return True; else return Fasle; 　　2、if (   ($Year%4==0  &am
  • java进阶，《Java性能优化权威指南》试读 darkblue086 java性能优化
    记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
  • 网络学习笔记初识OSI七层模型与TCP协议 dcj3sjt126com 学习笔记
      协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定 　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。 　　两类服务： 　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。 　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
  • mac中用命令行运行mysql dcj3sjt126com mysqllinuxmac
    参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html  感觉workbench不好用（有点先入为主了）。 1，安装mysql 在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
  • MongDB查询（1）——基本查询[五] eksliang mongodbmongodb 查询mongodb find
    MongDB查询 转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 MongoDB中使用find来进行查询。 API:如下 function ( query , fields , limit , skip, batchSize, options ){.....}  参数含义： query:查询参数 fie
  • base64，加密解密 经融加密，对接 y806839048 经融加密对接
    String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); // 注意编码格式，注意用于加密，解密的要是同
  • JavaWeb之JSP概述 ihuning javaweb
      什么是JSP？为什么使用JSP？ JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。   JSP起源    在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。  如果使用Servl
  • apple watch 指南 啸笑天 apple
    1. 文档 WatchKit Programming Guide（中译在线版 By @CocoaChina） 译文 译者 原文 概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch 概览 - 配置 Xcode 项目 - Overview - Configuring Yo
  • java经典的基础题目 macroli java编程
    1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
  • 你所不知道神奇的js replace正则表达式 qiaolevip 每天进步一点点学习永无止境纵观千象regex
    var v = 'C9CFBAA3CAD0'; console.log(v); var arr = v.split(''); for (var i = 0; i < arr.length; i ++) { if (i % 2 == 0) arr[i] = '%' + arr[i]; } console.log(arr.join('')); console.log(v.r
  • [一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics) superlxw1234 hivehive分析表hive统计信息hive Statistics
    关键字：Hive统计信息、分析Hive表、Hive Statistics   类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。   表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等；   14.1 新表的统计信息 对于一个新创建
  • Spring Boot 1.2.5 发布 wiselyman spring boot
        Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。   这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。   官方建议所有的Spring Boot用户升级这个版本。   项目首页 | 源
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他