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小练习系列 Vol.10：埃氏筛法（高效素数筛选） 滴答滴答滴嗒滴 Python小练习python算法开发语言
    Python小练习系列Vol.10：埃氏筛法（高效素数筛选）✨本期带你掌握一个古老但高效的算法——埃拉托色尼筛法（SieveofEratosthenes）。埃拉托斯特尼筛法，简称埃氏筛或爱氏筛，是一种由希腊数学家埃拉托斯特尼所提出的一种简单检定素数的算法。要得到自然数n以内的全部素数，必须把不大于根号n的所有素数的倍数剔除，剩下的就是素数。一、题目描述给定一个正整数n，请找出所有小于等于n的素数（
  • Python小练习系列 Vol.4：迷宫寻路（回溯 + DFS） 滴答滴答滴嗒滴 Python小练习深度优先python算法
    Python小练习系列Vol.4：迷宫寻路（回溯+DFS）本期我们将探索一个二维世界，借助回溯算法帮助角色走出迷宫！这是学习路径搜索类题目的经典案例。一、题目描述给定一个二维迷宫地图（由0和1组成），其中0表示可以通行，1表示障碍。请找出从起点(0,0)到终点(n-1,m-1)的一条可行路径（若存在），并打印路径坐标。示例输入：maze=[[0,1,0,0],[0,0,0,1],[1,1,0,1]
  • 智能优化算法应用：基于JAYA算法与双伽马校正的图像自适应增强算法 智能算法研学社（Jack旭） 智能优化算法应用图像增强算法计算机视觉人工智能
    智能优化算法应用：基于JAYA算法与双伽马校正的图像自适应增强算法-附代码文章目录智能优化算法应用：基于JAYA算法与双伽马校正的图像自适应增强算法-附代码1.全局双伽马校正2.JAYA算法3.适应度函数设计4.实验与算法结果5.参考文献6.Matlab代码摘要：本文主要介绍基于JAYA算法与双伽马校正的图像自适应增强算法。1.全局双伽马校正设图像的灰度值范围被归一化到[0,1]范围之内，基于全局
  • 远程温度控制系统设计与实现（含有源码） 妄北y xcodemacoside单片机嵌入式硬件
    1.引言在现代工业及家庭生活中，温度控制技术扮演着关键角色。随着人们对生活质量的不断追求，温度控制系统的需求日益增加。本项目旨在设计一个基于微控制器的远程温度控制系统，主要功能包括温度监测、温度设定及无线通信。2.系统设计概述2.1设计任务本项目的设计任务包括：设计远程温度控制系统，电烤箱温度可由人工设定，控制范围室温至125℃。采用PID控制算法实现温度实时控制，并能显示实际温度值。实现无线发送
  • 面经分享，中科创达（安卓开发，二面挂） 慕容魏 java开发语言
    首先是评价，公司属于是新成立的外资合资企业，主要是对德和对日。然后一面线上面试很简单，二面线下技术主管和HR一起面试，强度较大比较细腻，但是面试官很温和很耐心。一面（因为是安卓开发，不对口，就只问了Java）1.Java高并发多线程理解，线程池参数2.Java集合3.list具体，以及和map区别4.hashmap的底层原理5.数据结构，集合队列和树6.项目里面的和安卓开发有关吗，讲解一下7.排序
  • 推荐算法分析 乘秋川 毕设推荐算法
    一、性能分析指标1.准确性指标（AccuracyMetrics）衡量推荐系统预测评分的准确性，包括：✅RMSE（均方根误差,RootMeanSquaredError）解释：衡量预测评分(\hat{r}_i)和真实评分(r_i)之间的偏差，数值越低表示误差越小。适用场景：适用于评分预测任务，比如电影评分推荐（1~5星）。缺点：对大误差更敏感，如果有极端值（outliers），RMSE可能会偏大。✅M
  • 操作系統恐龍書第十版課後答案 ch12 單細胞生物 系统架构
    12.1Statethreeadvantagesofplacingfunctionalityinadevicecontroller,ratherthaninthekernel.Statethreedisadvantages.優點：bug不太可能導致系統崩潰；通過使用專用硬體和硬編碼演算法可以提高性能；通過將算法移出核心可以簡化缺點：bug更難修復改進演算法也需要硬體更新嵌入式演算法可能與應用程序對
  • 深入理解 C 语言头文件：从基础到高级应用 烂蜻蜓 c语言算法开发语言
    引言在C语言的编程世界里，头文件扮演着不可或缺的角色。无论是进行简单的程序开发，还是构建复杂的软件系统，头文件都能帮助我们组织代码，实现代码的模块化与复用。本文将深入探讨C语言头文件的各个方面，从其基础概念到高级应用，助您全面掌握头文件的使用技巧。一、头文件是什么头文件是扩展名为.h的文件，它包含了C函数声明、宏定义等内容，这些内容可被多个源文件引用共享。头文件主要分为两类：程序员编写的自定义头文
  • 算法试题——每日一练 0202ohh 算法刷题（C语言）算法数据结构c语言
    求整数x的平方根给定一个非负整数，求它的平方根，只要整数部分。第一次通过的代码：intmySqrt(intx){longintlow,high,mid,t;low=0;high=x;while(lowx/g){g/=2;}//对应上面的while(t*tintclimbStairs(intn){if(nintclimbStairs(intn){inta,b,c;if(nintremoveDupli
  • rust学习之所有权，引用和借用 李某学编程 李某学rustrust学习开发语言
    1.什么是所有权？1.1关于堆内存的题外话所有权是rust独有的概念，是一种资源管理机制，主要是针对堆内存管理的，栈也没啥好管理的，在编译时以及程序运行时自动完成，不需要人为干预，而堆就不一样了，拿C语言来说，其最基本的申请堆内存的函数malloc，申请的内存用完以后都要使用free及时释放，要不然就会造成大名鼎鼎的内存泄漏，但是我觉得应该有很多很多人在初学的时候总是忘记释放，而且由于堆内存的特殊
  • ViconTracker&MotionBuilder动作捕捉流程 PPPPaws viconmotioncapture
    #意识流笔记，没有图#使用的动捕设备：vicon一、打开vicontracker软件1.标定摄像机切换到camera视图；在calibrate面板，开始calibratecameras，挥舞标定杆直到每个摄像头有4000点，停止calibratecameras。目的是标定摄像机间的相对位置；在calibrate面板，开始setvolunnorigin，将标定杆放于原点，停止setvolunnori
  • 算法每日一练 (19) 张翊尘 算法每日一练算法数据结构
    欢迎来到张翊尘的技术站技术如江河，汇聚众志成。代码似星辰，照亮行征程。开源精神长，传承永不忘。携手共前行，未来更辉煌文章目录算法每日一练(19)不同路径题目描述解题思路解题代码`c/c++``golang``lua`官方站点：力扣Leetcode算法每日一练(19)不同路径题目地址：不同路径题目描述一个机器人位于一个mxn网格的左上角（起始点在下图中标记为“Start”）。机器人每次只能向下或者向
  • 算法每日一练 (20) 张翊尘 算法每日一练算法数据结构
    欢迎来到张翊尘的技术站技术如江河，汇聚众志成。代码似星辰，照亮行征程。开源精神长，传承永不忘。携手共前行，未来更辉煌文章目录算法每日一练(20)不同路径II题目描述解题思路解题代码`c/c++``golang``lua`官方站点：力扣Leetcode算法每日一练(20)不同路径II题目地址：不同路径II题目描述给定一个mxn的整数数组grid。一个机器人初始位于左上角（即grid[0][0]）。机
  • 《Python机器学习基础教程》第十二章计算机视觉基础12.8 深度解析：目标检测算法（R-CNN、Fast R-CNN、Faster R-CNN、YOLO和SSD）及其应用场景 精通代码大仙 机器学习python机器学习开发语言
    12.8深度解析：目标检测算法（R-CNN、FastR-CNN、FasterR-CNN、YOLO和SSD）及其应用场景12.8目标检测12.8.1目标检测的基本概念12.8.2R-CNN12.8.3FastR-CNN12.8.4FasterR-CNN12.8.5YOLO12.8.6SSD12.8.7实操代码示例12.8.7.1使用R-CNN进行目标检测12.8.7.2使用FastR-CNN进行目标
  • FreeRTOS之任务栈 古希腊掌握嵌入式的神 单片机嵌入式硬件操作系统freertos嵌入式
    1.任务栈是什么？任务栈是每个任务在运行时用来存储局部变量、函数调用参数和返回地址的一片内存区域。在FreeRTOS中，每个任务都有自己的独立栈空间，这样可以避免任务之间的相互干扰。栈，简单来说，是一种数据结构，它按照“后进先出”的规则存储数据。用通俗易懂的比喻来说，假设你要去参加一场冒险，你得带上各种东西，像地图、食物、工具等等。这个用来装这些东西的背包，就类似于任务栈在程序中的角色。2.任务栈
  • 椭圆曲线密码学（ECC）深度解析：下一代非对称加密的核心 安全
    引言在移动支付和物联网设备爆炸式增长的今天，传统RSA算法2048位密钥的庞大体积已成为性能瓶颈。椭圆曲线密码学（ECC）以256位密钥实现相同安全强度的特性，正在重塑现代密码学格局。本文将深入解析ECC的数学原理与工程实现，为计算机专业学生构建系统的密码学认知体系。一、椭圆曲线的代数结构与离散化1.1椭圆曲线方程的特殊构造标准椭圆曲线方程$y^2=x^3+ax+b$在实数域上形成闭合的平滑曲线，
  • 信息系统项目管理师必背核心考点（七十三）黑/白/灰盒测试 qiangge2015 培训信息系统项目管理师科科过信息系统项目管理师信息系统项目管理师考点信息系统项目管理师黑盒测试
    科科过为您带来软考信息系统项目管理师核心重点考点（七十三）黑盒测试，内含思维导图+真题【信息系统项目管理师核心考点】黑盒测试一、又称界面测试或功能测试，从用户的角度出发，把程序看作一个不能打开的黑盒子，完全不考虑程序内部结构和内部特性，例如依据需求分析阶段的文档，看功能是否适用客户要求二、主要针对软件界面和软件功能进行测试三、用例设计方法1.等价类划分法把所有可能的输入数据，即程序的输入域划分为若
  • 信息系统项目管理师必背核心考点（七十）安全审计功能 qiangge2015 软考高级信息系统项目管理师软考培训信息系统项目管理师科科过信息系统项目管理师信息系统项目管理师考点信息系统项目管理师安全审计功能
    科科过为您带来软考信息系统项目管理师核心重点考点（七十）安全审计功能，内含思维导图+真题【信息系统项目管理师核心考点】安全审计功能1.安全审计自动响应功能2.安全审计自动生成功能3.安全审计分析功能4.安全审计浏览功能5.安全审计事件选择功能6.安全审计事件存储功能【核心考点思维导图】【核心考点真题】1.()指对主体访问和使用客体的情况进行记录和审查，以保证安全规则被正确执行，并帮助分析安全事故产
  • 信息系统项目管理师必背核心考点（六十八）数字证书、数字签名 qiangge2015 信息系统项目管理师软考软考高级科科过信息系统项目管理师信息系统项目管理师考点信息系统项目管理师培训信息系统项目管理师数字证书数字签名
    科科过为您带来软考信息系统项目管理师核心重点考点（六十八）数字证书、数字签名和CA认证中心，内含思维导图+真题【信息系统项目管理师核心考点】数字证书1.具有不可抵赖性的特征（一段电子文档）2.包含信息：①版本号②序列号③签名算法标识符④认证机构⑤有效期限⑥主题信息⑦认证机构的数字签名⑧公钥信息【信息系统项目管理师核心考点】数字签名防止信息抵赖（发送者的私钥加密）【信息系统项目管理师核心考点】CA认
  • 永磁同步电机无速度算法--基于宽频带同步基频提取滤波器的滑模观测器 Neil motor 算法
    一、原理介绍当电机运行至中高速阶段时，反电动势能被观测器准确估计，因此基于电机模型的反电动势法成为无位置控制系统的不二之选。而SMO由于对电机参数变化不敏感，鲁棒性高，结构简单等优点被广泛应用。在实际应用中，无位置控制系统中的开关频率受时间延迟、系统惯性以及数字离散化等的限制，不能满足控制函数可无限开关的条件，因此，状态变量只能在稳定点来回小幅度运动，而不能收敛在平衡点处，因此导致滑模观测器的抖振
  • 3.27学习总结 2402_88131930 学习
    今天完成组合总和II的算法题，相对于之前的多了一个复杂的去重工作，因为它里面有重复的元素，需要去重，先排序，如果遍历到的值和前一个相同则跳过跟着黑马的Java做拼图的项目
  • 思维链在环境污染源追踪中的新角色 AI大模型应用之禅 DeepSeekR1&AI大模型与大数据ai
    《思维链在环境污染源追踪中的新角色》关键词：环境污染源追踪，思维链，人工智能，数据挖掘，环境监测摘要：随着全球环境污染问题的日益严峻，如何有效地追踪环境污染源已成为当前环保领域的重要任务。本文将探讨思维链这一新兴技术手段在环境污染源追踪中的应用，分析其理论基础、组成结构、核心概念及其在实际操作中的应用。通过对环境污染源追踪问题的背景介绍、核心概念与联系的分析、算法原理的讲解以及系统分析与架构设计的
  • 【推荐系统】由浅入深 HP-Succinum 机器学习算法机器学习人工智能
    目录一、相似度计算方法1.杰卡德系数2.余弦相似度3.编辑距离二、推荐系统算法1.基于内容的推荐系统2.协同过滤推荐系统三、冷启动问题与数据稀疏性问题1.冷启动问题2.数据稀疏性问题四、数据预处理的重要性五、结论在互联网时代，推荐系统已经成为各大平台提升用户体验和增加用户粘性的重要工具。无论是电商平台的商品推荐，还是视频平台的内容推荐，其核心思想都是通过计算对象之间的相似度，为用户提供个性化的推荐
  • 【c++笔试强训】（第四十七篇） single594 c++开发语言算法java牛客
    目录活动安排（贪⼼-区间）题目解析讲解算法原理编写代码合唱团（动态规划-线性dp）题目解析讲解算法原理编写代码活动安排（贪⼼-区间）题目解析1.题目链接：活动安排_牛客题霸_牛客网2.题目描述描述给定nn个活动，每个活动安排的时间为[a_i,b_i)[ai,bi)。求最多可以选择多少个活动，满足选择的活动时间两两之间没有重合。输入描述：第一行输入一个整数nn(1\len\le2\cdot10^51
  • 【贪心算法】（第十二篇） single594 1024程序员节贪心算法算法数据结构javac++vscode
    目录⽆重叠区间（medium）题目解析讲解算法原理编写代码⽤最少数量的箭引爆⽓球（medium）题目解析讲解算法原理编写代码⽆重叠区间（medium）题目解析1.题目链接：.-力扣（LeetCode）2.题目描述给定⼀个区间的集合intervals，其中intervals[i]=[start(i),end(i)]。返回需要移除区间的最⼩数量，使剩余区间互不重叠。⽰例1:输⼊:intervals=[
  • 【优选算法】（第二十五篇） single594 算法数据结构javac++leetcode排序算法vscode
    目录计算右侧⼩于当前元素的个数（hard）题目解析讲解算法原理编写代码翻转对（hard）题目解析讲解算法原理编写代码计算右侧⼩于当前元素的个数（hard）题目解析1.题目链接：.-力扣（LeetCode）2.题目描述给你⼀个整数数组nums，按要求返回⼀个新数组counts。数组counts有该性质：counts[i]的值是nums[i]右侧⼩于nums[i]的元素的数量。⽰例1：输⼊：nums=
  • 机器学习中使用Seaborn绘制KDE核密度估计曲线 闵少搞AI 人工智能机器学习人工智能算法
    核密度估计图(KDE)核密度估计（KDE）图，一种可视化技术，提供连续变量概率密度的详细视图。在本文中，我们将使用IrisDataset和KDEPlot来可视化数据集。在机器学习中，核密度估计（KDE）不仅用于可视化数据分布，还被用作一种非参数方法来估计数据的概率密度函数。这在特征工程、异常检测、生成模型等领域中有重要应用。核密度估计在机器学习中的应用特征工程：通过KDE可以理解特征的分布情况，从
  • c语言线程Pthread讲解 jacklin_001 C语言学习笔记
    POSIX线程（POSIXthreads），简称Pthreads，是线程的POSIX标准。该标准定义了创建和操纵线程的一整套API。在类Unix操作系统（Unix、Linux、MacOSX等）中，都使用Pthreads作为操作系统的线程。Windows操作系统也有其移植版pthreads-win32作用线程库实行了POSIX线程标准通常称为Pthreads。POSIX线程具有很好的可移植性，使用p
  • 从基础到实践（二十三）：MCU选型设计指南 硬件进化论 单片机嵌入式硬件硬件工程电脑数码相机智能手表智能电视
    MCU（微控制器）是电子系统的核心控制单元，负责协调硬件资源与执行关键任务。其高度集成CPU、存储器、定时器及丰富外设（ADC、PWM、通信接口等），可实时处理传感器数据、驱动执行机构，并实现复杂算法（如PID控制）。在工业、汽车、消费电子等领域，MCU通过精准控制、低功耗管理及多协议通信，确保系统高效可靠运行。其小型化与低成本特性，使其成为万物互联时代智能设备的“大脑”，支撑从简单开关控制到边缘
  • 【多线程-第四天-SDWebImage初体验 Objective-C语言】 清风清晨 Objective-Cobjective-c开发语言macos
    一、SDWebImage初体验1.下边我们来快速的使用一下SDWebImage，看看它是否足够的方便，1）首先，导入一个SDWebImage提供给我们的一个分类，#import“UIImageView+WebCache.h”2）调用一行代码[self.imageViewsd_setImageWithURL:url]；这件事情就OK了，OK的话，我们要做一个练习，就做我们之前的这个练习，就是我们之前
  • 多线程编程之卫生间 周凡杨 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 半仙 alxw4616@Msn.com 目的: 项目需求实现模糊查找. 原则: 查询不能超过 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其他