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语言,图)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • 展现思维导图魅力，不断挖掘人生宝藏 思维导图讲师Mandy
    第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 2019-11-04复盘——飞来山上千寻塔，闻说鸡鸣见日升。 那一叶秋
    1、大盘篇先上老图，看习惯了，也就知道走势了图1上证指数日线图还是那张老图，自己可以在自己的相关软件上画出来，快变盘了。2、个股篇未加仓、未减仓。分析量能的时候，突然发现这么一个东西：“放量突破年线，缩量回调。”合众科技日线图其实，最近的N只个股，在技术分析上，都到了变盘的临界时候。结合这么久的走势，特别是ZJH不断放开IPO的申请，本质上说是融资难度变大，或者说是为企业的融资开创便利。但现在市场
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
    ?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • C语言 判断回文数 Y雨何时停T c语言学习
    一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
  • 父母教育孩子的方式，将影响孩子一生 树英教育
    为什么有些孩子总是充满自信与快乐？独立、有主见又坚强？而有些孩子却自卑、胆怯，软弱又过度依赖父母？为什么有些孩子总是健康、阳光又富于创造力？而有些孩子却悲观、孤僻又思想空乏？一个孩子的行为取决于孩子的思想，思想取决于环境和自己的认知，认知取决于教育。父母是孩子人生中的第一位教育者，父母养育孩子的方式，将决定他们人生的高度，影响他们的一生。网络图，侵权即删优秀的父母就像园丁，既要浇水施肥，又要修剪杂
  • 推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • 多线程编程之卫生间 周凡杨 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其他