tu

  1 第五章    图
  2 //结构定义
  3 #define MaxVertexNum 100    //图中顶点数目的最大值
  4 typedef    struct ArcNode{        //边表节点
  5     int adjvex;                    //该弧所指向的结点的位置
  6     struct ArcNode *nextarc;    //指向下一条边的指针
  7     //InfoType info ;            //网的边权值
  8 }ArcNode;
  9
 10 typedef struct VNode{    //顶点表结点
 11     VertexType data;    //顶点信息
 12     ArcNode *firstarc;        //指向第一条依附该顶点的弧的指针
 13 }VNode,AdjList[MaxVertexNum];
 14
 15 typedef struct{
 16     AdjList    vertices;    //邻接表
 17     int vexnum, arcnum;    //图的顶点数和弧数
 18 }ALGraph;                //ALGraph是以邻接表存储的图类型
 19
 20
 21
 22
 23
 24 例1、已知G为邻接矩阵存储，请设计一个算法将其转换为 邻接表存储
 25 void     MatrixToAdj(int A[])
 26 {
 27     //初始化顶点表
 28     for (int i=0;i<vertices;i++)    //vertices 图中顶点数
 29     {
 30         adjList[i].firstarc = NULL;    //firstarc指向第一条边的指针        adjList[]邻接表
 31     }
 32
 33     //循环遍历邻接矩阵，当值为1时，则对顶点i后加上一个结点j
 34     for (int i = 0 ; i < vertices ; i++)
 35     {
 36         for (int j = 0; j<vertices; j++)
 37         {
 38             if ( A[i][j] == 1)
 39             {
 40                 ENode *p = (ENode*)malloc(sizeof(ENode));    //申请一个新的边结点
 41                 p->adjvex = j;            //该边结点的指向的结点位置为j
 42                 p->nextarc = adjList[i].firstarc;   //边结点指向的下一条边的指针指向第一条边结点
 43                 adjList[i].firstarc = p;    //第一条边结点=p    //这里采用了头插法
 44             }
 45         }
 46     }
 47 }
 48
 49 思考题：改成尾插法 考虑插第一个顶点和后续顶点的区别。
 50
 51
 52 例2、邻接表转邻接矩阵     *****
 53 void AdjToMatrix(Graph G)
 54 {
 55     int A[vertices][vertices];
 56
 57     for(int i = 0; i < vertices; i++)    //将邻接矩阵清零
 58     {
 59         for (int j = 0; j < vertices; j++)
 60         {
 61             A[i][j] = 0;
 62         }
 63     }
 64
 65     for (int i = 0; i < G.vertices; i++)    //
 66     {
 67         ENode *p = G.adjList[i].firstarc;
 68         while(p!=NULL)
 69         {
 70             A[i][p->adjvex] = 1;
 71             p = p->nextarc;
 72         }
 73     }
 74 }
 75
 76
 77
 78 EX3、有向图G邻接表存储，计算各顶点的出度。    *****
 79 #define int A[G.n]    //置0
 80 void Outcount(AGraph* G)
 81 {
 82     int i = 0;    //用来计数
 83     while(i < G.n)
 84     {
 85         VNode p = G.adjList[i];
 86         ArcNode *q = p.firstarc;
 87         while(q!=NULL)
 88         {
 89             A[i]++;
 90             q=q->nextarc;
 91         }
 92         i++;
 93     }
 94 }
 95
 96 EX4、用邻接矩阵存储有向图，计算各节点入度出度     *****
 97 //思想：邻接矩阵来计算度，就是遍历二维数组
 98 //统计每行不为零的数，就是出度；每列不为零的数就是入度。
 99 //使用两个数组一个存放入度，一个存放出度
100 #define outDegree[G.n]
101 #define inDegree[G.n]
102 void count(MGraph* G)
103 {
104     int A[G.n][G.n] = G.edges;
105     int i=j=0;
106     //出度
107     while(i < G.n)
108     {
109         while(j < G.n)
110         {
111             if (A[i][j] !=0)
112                 outDegree[i]++;
113             j++;
114         }
115         i++;
116     }
117     //入度
118     while(j < G.n)
119     {
120         while(i < G.n)
121         {
122             if (A[i][j] !=0)
123                 inDegree[j]++;
124             i++;
125         }
126         j++;
127     }
128
129 }
130
131 EX5
132     由邻接表存储方式的有向图，根据此，写出算法，输出其对应的邻接矩阵
133 //扫描邻接表中的所有边结点，然后根据其所连接的顶点号，将邻接矩阵对应位置设为1即可
134 void AGraphToMGraph(MGraph &g1, AGraph g2)
135 {
136     ArcNode *p;
137     int i,j;
138     //将g1的邻接矩阵清零
139     for (i=0;i<g1.n;++i)
140         for (j=0;j<g1.n;++j)
141             g1.edges[i][j] = 0;
142     /*使用p指针扫描邻接表中的所有边结点*/
143     for (i=0;i<g2.n;++i)
144     {
145         p= g2.adjList[i].firstarc;
146         while (p)
147         {
148             g1.edges[i][p->adjVex] = 1;
149             p = p->nextarc;
150         }
151     }
152 }
153
154
155 DS:计算各顶点的入度和出度        邻接表
156 void DegreeCount(LGraph *G,int inDegree[], int outDegree[])
157         //inDegree[]用来储存入度    outDegree[]用来储存出度
158 {
159     int i,count;    //i表示顶点，count用来计数
160     ArcNode *p;        //p指针用来扫描每个顶点所发出的边
161
162     for(i=0;i<G->n;i++)        //将储存度的数组置零
163         inDegree[i]=outDegree[i]=0;
164
165     for(int i=0;i<G->n;i++)
166     {
167         count=0;    //计数器清零
168         p=G->adjList[i].firstarc;
169         p=G->a[i];
170         while(p)
171         {
172             count++;
173             inDegree[p->adjVex]++;
174         }
175         outDegree[i]=count;
176     }
177 }
178
179 EX
180     写一个递归算法，在二叉树中搜索指定结点右孩子
181     如果有右孩子则返回右孩子的函数值并返回TRUE;若没有右孩子则返回FALSE
182 //想法，写两个函数体，一个主函数，一个递归程序，递归程序就是对遍历的该写
183 //同时还需要写一个搜索值，找到指定结点，判断其是否有右孩子，有就将有孩子的值赋给变量返回，没有就return false
184 #define int e
185 #define bool flage=false
186 bool searchRchlid(int X ,BTree * p)
187 {
188     if (p == NULL)
189         return false;
190     else
191         PreOrder(p,x);
192         return flage;
193 }
194 bool PreOrder(BTnode *p, int X)
195 {
196     if(p!= NULL)
197     {
198         if ( p->data == x)
199         {
200             if (p->Rchlid!=NULL)
201                 e = p->Rchlid->data;
202                 flage=ture;
203             }
204             break;
205         }
206         PreOrder(p->Lchlid,x);
207         PreOrder(P->Rchlid,x);
208     }
209 }
210
211
212 哈夫曼树加权路径长度
213 #define int sum = 0
214 #define int high = 0
215 void preorder(BTree *p)
216 {
217     if (p!=NULL)
218     {
219         if (p->lchild==NULL&&p->rchild==NULL)
220             sum = sum + p->element*high;
221         ++high;
222         preorder(p->lchild);
223         preorder(p->rchild);
224         --high;
225     }
226 }
227
228
229 用单链表实现简单选择排序
230 {void main(LNode *p)
231 {
232     LNode *flag = *p;
233     while (flag->next != NULL)
234     {
235         LNode *q = findMin(flag);
236         LNode *r = q->next;
237         q->next = r->next;    //dd
238         r->next = flag->next;
239         flag->next=r;
240         flag=flag->next;
241     }
242 }
243 LNode findMin(LNode *flag)
244 {
245     LNode *min = flag;
246     LNode *r =flag;
247     while(r->next!=NULL)
248     {
249         if(r->next->data < min->next->data)
250             min = r;
251         r = r->next;
252     }
253     return min;
254 }}
255             

tu