12/25每日总结-CFANZ编程社区

树与二叉树的转化

树要变成二叉树，那就将树中的所有兄弟结点进行链接，然后每一层与上一层的连接只留下第一个结点的连接

二叉树要变成树，那就反方向来一次，将除了第一个结点的其他结点与根节点连接上，然后将兄弟结点连接，这时候二叉树就变回了原来的树

森林与二叉树的转化

森林转化为二叉树，森林是由若干个树组成的，可以理解为森林中的每棵树都是兄弟，我们先把森林中的每棵树转化成二叉树，然后将从第二个树起的每个结点作为上一个结点的右孩子

二叉树想转化成森林，先要看他可不可以转化，直接看根节点有没有右孩子，有就可以转化，先递归的将每个拥有右节点的根节点都断开然后将二叉树再转化成树就成了森林

树与森林的遍历

树的遍历

树的遍历很简单，分为先根遍历与后根遍历

森林的遍历

森林的遍历也分为两种，分别是前序遍历与后序遍历，森林的前序遍历与二叉树的中序遍历相同，森林的后序遍历与二叉树的中序遍历相同

图

图的表示

邻接矩阵

typedef struct
 {
     Vertextype vexs[MAXVEX];
     EdgeType arc[MAXVEX][MAXVEX];
     int numNodes, numEdges;
 }MGraph;

邻接表

int EdgeType;
 typedef struct
 {
     int adjvex;
     EdgeType info;
     struct EdgeNode *next;
 }EdgeNode;
 typedef struct
 {
     VertexType data;
     EdgeNode *firstedge;
 }VertexNode,AdjList[MAXVEX];
 typedef struct
 {
     Adjlist adjList;
     int numNodes,numEdges;
 }AdjList;

深度优先搜索

深度优先搜索也叫DFS，这种搜索如其名，深度优先，在走之前先确定一个方向，比如先访问最左边的，那就持续往前走，在未遇到过的结点的路中选择最左边的即可

//邻接矩阵
 #define MAXVEX 9
 Boolean visited[MAXVEX]
 void DFS(MGraph G,int i)
 {
     int j;
     visited[i] = True;
     printf("%c",G.vexs[i])
     for(j = 0;j < MAXVEX;j++)
     {
         if(G.arc[i][j] == 1 && visited[i] == False)
         {
             DFS(G,j);
         }       
     }
 }
 void DFSTraverse(MGraph G)
 {
     int i;
     for(i = 0;i < G.numvertexes;i++)
     {
         visited[i] = False;
     }
     for(i = 0;i < G.numvertexes;i++)
     {
         if(!visited(i))
         {
             DFS(G,i);
         }
     }
 }

//邻接表
 void DFS(GraphAdjList GL,int i)
 {
     EdgeNode *p;
     visited[i] = True;
     printf("%c",GL->adjlist[i].data);
     p = GL->adjlist[i].firstedge;
     while(p)
     {
         if(!visted[p->adjvex])
         {
             DFS(GL,p->adjvex);
         }
         p = p->next;
     }
 }
 void DFSTraverse(GraphAdjlist GL)
 {
     int i;
     for(i = 0;i < GL->numvexes;i++)
     {
         visited[i] = False;
     }
     for(i = 0;i < GL->numvexes;i++)
     {
         if(!visited[i])
         {
             DFS(GL,i);
         }
     }
 }

广度优先搜索

广度优先搜索，也叫BFS

核心思想是一层一层访问结点，使用的是一个栈来作为辅助存储，从入栈第一个节点开始，每次出栈一个结点，就将这个结点邻接的所有未访问顶点入栈，由此来遍历所有顶点

void BFSTraverse(MGraph G)
 {
     int i;
     Queue Q;
     for(i = 0;i < G->numvexes;i++)
     {
         visited[i] = False;
     }
     InitQueue(Q);
     for(i = 0;i < G->numvexes;i++)
     {
         if(!visited[i])
         {
             visited[i] = True;
             printf("%c",G->vex[i])
             EnQueue(&Q,i);
             while(!EmptyQueue(Q))
             {
                 DeQueue(&Q,&i);
                 for(j = 0;j < G->numvexes;j++)
                 {
                     if(G.arc[i][j]&&!visited[j])
                     {
                         printf("%c",G->vex[j]);
                         EnQueue(&Q,j);
                     }
                 }
                 
             }
         }
     }
 }