厂工数据结构Anyview（C语言版）第七、八章答案（完结）

最新推荐文章于 2022-01-27 14:50:15 发布
最新推荐文章于 2022-01-27 14:50:15 发布
阅读量1.4k 收藏 11
点赞数 2
分类专栏： 数据结构Anyview答案 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48928539/article/details/113056428
版权

第七、八章

第七章

一、试编写算法，对一棵以孩子兄弟链表表示的树统计叶子的个数

【题目】试编写算法，对一棵以孩子兄弟链表表示的树统计叶子的个数。

孩子兄弟链表类型定义：
typedef struct CSTNode {
TElemType data;
struct CSTNode *firstChild, *nextSibling;
} CSTNode, *CSTree;

要求实现下列函数：
int Leave(CSTree T); /* 统计树T的叶子数 */

#include "allinclude.h"  //DO NOT edit this line
int Leave(CSTree T){ 
    // Add your code here
    
    if(!T) return 0;
    
    //如果当前结点的左孩子为空，则该左孩子就是一个叶子；返回它右兄弟的叶子数再加上左孩子这个叶子（+1）
    if(!T->firstChild) return 1+Leave(T->nextSibling);
    
    return Leave(T->firstChild)+Leave(T->nextSibling);
}

二、试编写算法，求一棵以孩子兄弟链表表示的树的度

【题目】试编写算法，求一棵以孩子兄弟链表表示的树的度。

孩子兄弟链表类型定义：
typedef struct CSTNode {
TElemType data;
struct CSTNode *firstChild, *nextSibling;
} CSTNode, *CSTree;

要求实现下列函数：
int Degree(CSTree T); /* 求树T的度 */

#include "allinclude.h"  //DO NOT edit this line
int Degree(CSTree T){ 
    // Add your code here
    
    if(!T) return 0;
    
    CSTree p;
    int sum1,sum2,sum;
    
    sum1 = 0;
    sum = 0;
    sum2 = 0;
    
    p = T->firstChild;
    
    while(p){
      
      sum1++;
      
      sum2 = Degree(p);
      
      //sum记录每个结点的子树的度中的最大值
      sum = sum>sum2?sum:sum2;
      
      p = p->nextSibling;
    
    //返回当前结点的度与子树中的最大度中的较大值
    return sum1>sum?sum1:sum;
}

三、试编写算法，对以双亲表示法存储的树计算深度

【题目】试编写算法，对以双亲表示法存储的树计算深度。

树的双亲表示法的类型定义如下：
typedef struct {
TElemType data;
int parent; // 双亲位置
} PTNode; // 结点类型
typedef struct {
PTNode nodes[MAX_TREE_SIZE]; // 结点存储空间
int n, r; // 结点数和根的位置
} PTree;

要求实现以下函数：
int PTreeDepth(PTree T); /* 求树T的深度 */

#include "allinclude.h"  //DO NOT edit this line
int PTreeDepth(PTree T){ 
    // Add your code here
  
    int i,j,dep,depmax = 0;
    
    for(i = 0;i < T.n;i++){
      
      //用dep记录到当前层的深度-1（除根结点）
      dep = 0;
      
      for(j = i;j > 0;j = T.nodes[j].parent) dep++;
      
      //与上一个结点的深度比较，取最大值
      depmax = dep>depmax?dep:depmax;
    }
    
    return depmax+1;//加上根节点那一层！
}

四、试编写算法，对以双亲孩子表示法存储的树计算深度

【题目】试编写算法，对以双亲孩子表示法存储的树计算深度。

孩子链表类型定义：
typedef struct ChildNode { // 孩子结点
int childIndex;
struct ChildNode *nextChild;
} ChildNode; // 孩子结点类型
typedef struct {
TElemType data;
int parent; // 双亲位置
struct ChildNode *firstChild; // 孩子链表头指针
} PCTreeNode; // 结点类型
typedef struct {
PCTreeNode *nodes; // 结点存储空间
int n, r; // 结点数和根的位置
} PCTree;

要求实现下列函数：
int PCTreeDepth(PCTree T); /* 求树T的深度 */

#include "allinclude.h"  //DO NOT edit this line
int Depth(PCTree T, int pos){ //构造一个可以由任意结点位置计算出深度的函数
    // Add your code here
    
    if(!T.nodes[pos].firstChild) return 1;
    
    ChildNode *temp = T.nodes[pos].firstChild;
    int depth,max;
    
    depth = 1;
    max = 1;
    
    //遍历每一个结点的孩子
    while(temp){
      
      //递归算出以每个结点为根结点的树的深度，并找出深度最大值，用max记住
      if(T.nodes[temp->childIndex].firstChild){
        
        depth = Depth(T,temp->childIndex);
        
        max = max>depth?max:depth;
        
      }
        
        temp = temp->nextChild;
    }
    
    return max+1;
} 

int PCTreeDepth(PCTree T){
  
  return Depth(T,T.r);
}

五、试编写算法，对以孩子-兄弟链表表示的树计算深度

【题目】试编写算法，对以孩子-兄弟链表表示的树计算深度。

孩子兄弟链表类型定义：
typedef struct CSTNode {
TElemType data;
struct CSTNode *firstChild, *nextSibling;
} CSTNode, *CSTree;

要求实现下列函数：
int TreeDepth(CSTree T);
/* 求树T的深度 */

#include "allinclude.h"  //DO NOT edit this line
int TreeDepth(CSTree T){ 
    // Add your code here
    
    if(!T) return 0;
    
    int dep1,dep2;
    
    dep1 = TreeDepth(T->firstChild);
    dep2 = TreeDepth(T->nextSibling);
    
    return dep1+1>dep2?dep1+1:dep2;
}

六、试编写非递归算法，实现并查集带路径压缩的查找操作

【题目】试编写非递归算法，实现并查集带路径压缩的查找操作。

并查集的类型定义如下：
typedef struct {
int *parent;
int n;
} MFSet;

实现下列函数：
int find(MFSet S, int i);
/* 并查集带路径压缩的查找的非递归实现 */

#include "allinclude.h"  //DO NOT edit this line
int find(MFSet S, int i){ 
    // Add your code here
    
    if(i < 0||i >= S.n) return -1;
    
    int k,j;
    
    j = i;
    
    //用j记住根节点的位置
    while(S.parent[j] >= 0) j = S.parent[j];
    
    while(i != j){
      
      k = S.parent[i];//用k记住当前结点的父结点
      S.parent[i] = j;//把父结点换成根结点
      
      i = k;//转到原父结点重复操作
    }
    
    return j;
}

第八章

一、编写算法，创建有向图的邻接数组存储结构

【题目】编写算法，创建有向图的邻接数组存储结构。

图的邻接数组存储结构的类型定义如下：
#define UNVISITED 0
#define VISITED 1
#define MAX_VEX_NUM 4
#define INFINITY MAXINT // 计算机允许的整数最大值，即∞
typedef int VRType;
typedef char InfoType;
typedef char VexType;
typedef enum {DG,DN,UDG,UDN} GraphKind; // 有向图,有向网,无向图,无向网
typedef struct {
VRType adj; // 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否；
// 对带权图，则为权值类型
InfoType *info; // 该弧相关信息的指针(可无)
}ArcCell;//,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct {
ArcCell arcs[MAX_VEX_NUM][MAX_VEX_NUM]; // 关系数组
VexType vexs[MAX_VEX_NUM]; // 顶点数组
int n, e; // 顶点数和边（弧）数
GraphKind kind; // 图的类型
} MGraph; // 邻接数组类型
typedef struct {
VexType v, w;
int inf;
} ArcInfo;

可调用以下基本操作：
Status InitGraph(MGraph &G, GraphKind kind, int n);
// 初始化含n个顶点空间的kind类的空图G
int LocateVex(MGraph G, VexType v); // 查找顶点v在图G中的位序

要求实现以下函数：
Status CreateDG(MGraph &G, VexType *vexs, int n,
ArcInfo arcs, int e);
/ 创建含n个顶点和e条边的有向图G，vexs为顶点信息，arcs为边信息 */

#include "allinclude.h"  //DO NOT edit this line
Status CreateDG(MGraph &G, VexType *vexs, int n,
                           ArcInfo *arcs, int e){ 
    // Add your code here
    
    //初始化一个n个顶点空间的有向空图
    InitGraph(G,DG,n);
    
    int i,j,k,m;
    
    //赋值
    G.n = n;
    G.e = e;
    
    //构建顶点数组
    for(m = 0;m < n;m++){
      
      G.vexs[m] = vexs[m];
    }
    
    //构建邻接数组
    for(k = 0;k < G.e;k++){
      
      /*找到两个邻接顶点
      外部传入的arcs是一维数组，里面存储的是两个链接顶点的相关信息*/
      i = LocateVex(G,arcs[k].v);
      j = LocateVex(G,arcs[k].w);
      
      if(i < 0||j < 0) return ERROR;
      
      G.arcs[i][j].adj = 1;//有关系置位为1
      //G.arcs[i][j].info = arcs[k].inf;
    }
    
    return OK;
}

二、编写算法，在图G中，相对于k顶点的当前邻接顶点m顶点，求下一个邻接顶点

【题目】编写算法，在图G中，相对于k顶点的当前邻接顶点m顶点，求下一个邻接顶点。

图的邻接数组存储结构的类型定义如下：
#define UNVISITED 0
#define VISITED 1
#define MAX_VEX_NUM 4
#define INFINITY MAXINT // 计算机允许的整数最大值，即∞
typedef int VRType;
typedef char InfoType;
typedef char VexType;
typedef enum {DG,DN,UDG,UDN} GraphKind; // 有向图,有向网,无向图,无向网
typedef struct {
VRType adj; // 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否；
// 对带权图，则为权值类型
InfoType *info; // 该弧相关信息的指针(可无)
}ArcCell;//,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct {
ArcCell arcs[MAX_VEX_NUM][MAX_VEX_NUM]; // 关系数组
VexType vexs[MAX_VEX_NUM]; // 顶点数组
int n, e; // 顶点数和边（弧）数
GraphKind kind; // 图的类型
} MGraph; // 邻接数组类型

要求实现以下函数：
int NextAdjVex(MGraph G, int k, int m);
/* 在图G中，相对于k顶点的当前邻接顶点m顶点，求下一个邻接顶点 */

#include "allinclude.h"  //DO NOT edit this line
int NextAdjVex(MGraph G, int k, int m){ 
    // Add your code here
    
    //没有顶点时，返回0
    if(G.n == 0&&k == 0&&m == 0) return 0;
    
    for(int i = m+1;i < G.n;i++)
      if(G.arcs[k][i].adj == 1 ) return i;
    
    //没有找到目标顶点，返回-1
    return -1;
}

三、编写算法，在图G中置顶点v到顶点w的弧或边

【题目】编写算法，在图G中置顶点v到顶点w的弧或边。

图的邻接数组存储结构的类型定义如下：
#define UNVISITED 0
#define VISITED 1
#define MAX_VEX_NUM 4
#define INFINITY MAXINT // 计算机允许的整数最大值，即∞
typedef int VRType;
typedef char InfoType;
typedef char VexType;
typedef enum {DG,DN,UDG,UDN} GraphKind; // 有向图,有向网,无向图,无向网
typedef struct {
VRType adj; // 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否；
// 对带权图，则为权值类型
InfoType *info; // 该弧相关信息的指针(可无)
}ArcCell;//,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct {
ArcCell arcs[MAX_VEX_NUM][MAX_VEX_NUM]; // 关系数组
VexType vexs[MAX_VEX_NUM]; // 顶点数组
int n, e; // 顶点数和边（弧）数
GraphKind kind; // 图的类型
} MGraph; // 邻接数组类型

可调用以下基本操作：
int LocateVex(MGraph G, VexType v); // 查找顶点v在图G中的位序

要求实现以下函数：
Status SetArc(MGraph &G, VexType v, VexType w, ArcCell info);
/* 在图G中置顶点v到顶点w的弧或边 */

#include "allinclude.h"  //DO NOT edit this line
Status SetArc(MGraph &G, VexType v, VexType w, ArcCell info){ 
    // Add your code here
    
    if(v == w) return ERROR;//若两个顶点相等，则不能产生关系
    
    int i,j;
    
    i = LocateVex(G,v);
    j = LocateVex(G,w);
    
    if(i < 0||j <0) return ERROR;
    
    //当v和w没关系时再生成边，已经有关系就直接返回OK
    if(!G.arcs[i][j].adj){
      
      G.arcs[i][j] = info;
    
      G.e++;
    }
    
    return OK;
}

四、编写算法，计算以邻接表方式存储的有向图G中k顶点的出度

【题目】编写算法，计算以邻接表方式存储的有向图G中k顶点的出度。

图的邻接表存储结构的类型定义如下：
#define UNVISITED 0
#define VISITED 1
#define INFINITY MAXINT // 计算机允许的整数最大值，即∞
typedef char VexType;
typedef enum {DG,DN,UDG,UDN} GraphKind; // 有向图,有向网,无向图,无向网
typedef struct AdjVexNode {
int adjvex; // 邻接顶点在顶点数组中的位序
struct AdjVexNode *next; // 指向下一个邻接顶点（下一条边或弧）
int info; // 存储边（弧）相关信息，对于非带权图可不用
} AdjVexNode, *AdjVexNodeP; // 邻接链表的结点类型
typedef struct VexNode {
VexType data; // 顶点值，VexType是顶点类型，由用户定义
struct AdjVexNode *firstArc; // 邻接链表的头指针
} VexNode; // 顶点数组的元素类型
typedef struct {
VexNode *vexs; // 顶点数组，用于存储顶点信息
int n, e; // 顶点数和边（弧）数
GraphKind kind; // 图的类型
int *tags; // 标志数组
} ALGraph; // 邻接表类型

要求实现下列函数：
int outDegree(ALGraph G, int k);
/* 求有向图G中k顶点的出度。若k顶点不存在，则返回-1 */

#include "allinclude.h"  //DO NOT edit this line
int outDegree(ALGraph G, int k){ 
    // Add your code here
    
    if(k > G.n||k < 0) return -1;
    
    AdjVexNode *p = G.vexs[k].firstArc;
    int sum = 0;
    
    while(p){
      
      sum++;
      
      p = p->next;
    }
    
    return sum;
}

五、编写算法，计算以邻接表方式存储的有向图G中k顶点的入度

【题目】编写算法，计算以邻接表方式存储的有向图G中k顶点的入度。

图的邻接表存储结构的类型定义如下：
#define UNVISITED 0
#define VISITED 1
#define INFINITY MAXINT // 计算机允许的整数最大值，即∞
typedef char VexType;
typedef enum {DG,DN,UDG,UDN} GraphKind; // 有向图,有向网,无向图,无向网
typedef struct AdjVexNode {
int adjvex; // 邻接顶点在顶点数组中的位序
struct AdjVexNode *next; // 指向下一个邻接顶点（下一条边或弧）
int info; // 存储边（弧）相关信息，对于非带权图可不用
} AdjVexNode, *AdjVexNodeP; // 邻接链表的结点类型
typedef struct VexNode {
VexType data; // 顶点值，VexType是顶点类型，由用户定义
struct AdjVexNode *firstArc; // 邻接链表的头指针
} VexNode; // 顶点数组的元素类型
typedef struct {
VexNode *vexs; // 顶点数组，用于存储顶点信息
int n, e; // 顶点数和边（弧）数
GraphKind kind; // 图的类型
int *tags; // 标志数组
} ALGraph; // 邻接表类型

要求实现下列函数：
int inDegree(ALGraph G, int k);
/* 求有向图G中k顶点的入度。若k顶点不存在，则返回-1 */

#include "allinclude.h"  //DO NOT edit this line
int inDegree(ALGraph G, int k){ 
    // Add your code here
    
    if(k > G.n||k < 0) return -1;
    
    int sum = 0;
    AdjVexNode *p;
    
    for(int i = 0;i < G.n;i++){
      
      p = G.vexs[i].firstArc;
      
      while(p){
        
        if(p->adjvex == k) sum++;
        
        p = p->next;
      }
    }
    
    return sum;
}

六、编写算法，创建有向图的邻接表存储结构

【题目】编写算法，创建有向图的邻接表存储结构。

图的邻接表存储结构的类型定义如下：
#define UNVISITED 0
#define VISITED 1
#define MAX_VEX_NUM 4
#define INFINITY MAXINT // 计算机允许的整数最大值，即∞
typedef char VexType;
typedef enum {DG,DN,UDG,UDN} GraphKind; // 有向图,有向网,无向图,无向网
typedef struct AdjVexNode {
int adjvex; // 邻接顶点在顶点数组中的位序
struct AdjVexNode *next; // 指向下一个邻接顶点（下一条边或弧）
int info; // 存储边（弧）相关信息，对于非带权图可不用
} AdjVexNode, *AdjVexNodeP; // 邻接链表的结点类型
typedef struct VexNode {
VexType data; // 顶点值，VexType是顶点类型，由用户定义
struct AdjVexNode *firstArc; // 邻接链表的头指针
} VexNode; // 顶点数组的元素类型
typedef struct {
VexNode vexs[MAX_VEX_NUM]; // 顶点数组，用于存储顶点信息
int n, e; // 顶点数和边（弧）数
GraphKind kind; // 图的类型
int *tags; // 标志数组
} ALGraph; // 邻接表类型

可调用以下基本操作：
int LocateVex(ALGraph G, VexType v); // 查找顶点v在图G中的位序

要求实现下列函数：
Status CreateDG(ALGraph &G, VexType *vexs, int n,
ArcInfo arcs, int e);
/ 创建含n个顶点和e条边的有向图G，vexs为顶点信息，arcs为边信息 */

#include "allinclude.h"  //DO NOT edit this line
Status CreateDG(ALGraph &G, VexType *vexs, int n, ArcInfo *arcs, int e){ 
    // Add your code here
    
    int i,j,k,m;
    AdjVexNode *p;
    
    G.n = n;
    G.e = e;
    
    G.tags = (int *)malloc(n*sizeof(int));
    
    for(m = 0;m < n;m++){
      
      G.tags[m] = UNVISITED;//标志数组用于遍历
      G.vexs[m].data = vexs[m];
      G.vexs[m].firstArc = NULL;//别漏了这个初始化！
    }
    
    for(k = 0;k < e;k++){
      
      i = LocateVex(G,arcs[k].v);
      j = LocateVex(G,arcs[k].w);
      
      if(i < 0||j < 0) return ERROR;
      
      p = (AdjVexNode *)malloc(sizeof(AdjVexNode));
      
      if(!p) return ERROR;
      
      //每次都把w对应的结点插到v对应数组头结点的下一个结点
      p->adjvex = j;
      p->next = G.vexs[i].firstArc;
      G.vexs[i].firstArc = p;
    }
    
    return OK;
}

七、编写算法，创建无向图的邻接表存储结构

【题目】编写算法，创建无向图的邻接表存储结构。

图的邻接表存储结构的类型定义如下：
#define UNVISITED 0
#define VISITED 1
#define MAX_VEX_NUM 4
#define INFINITY MAXINT // 计算机允许的整数最大值，即∞
typedef char VexType;
typedef enum {DG,DN,UDG,UDN} GraphKind; // 有向图,有向网,无向图,无向网
typedef struct AdjVexNode {
int adjvex; // 邻接顶点在顶点数组中的位序
struct AdjVexNode *next; // 指向下一个邻接顶点（下一条边或弧）
int info; // 存储边（弧）相关信息，对于非带权图可不用
} AdjVexNode, *AdjVexNodeP; // 邻接链表的结点类型
typedef struct VexNode {
VexType data; // 顶点值，VexType是顶点类型，由用户定义
struct AdjVexNode *firstArc; // 邻接链表的头指针
} VexNode; // 顶点数组的元素类型
typedef struct {
VexNode vexs[MAX_VEX_NUM]; //*vexs; 顶点数组，用于存储顶点信息
int n, e; // 顶点数和边（弧）数
GraphKind kind; // 图的类型
int *tags; // 标志数组
} ALGraph; // 邻接表类型

可调用以下基本操作：
int LocateVex(ALGraph G, VexType v); // 查找顶点v在图G中的位序

要求实现下列函数：
Status CreateUDG(ALGraph &G, VexType *vexs, int n,
ArcInfo arcs, int e);
/ 创建含n个顶点和e条边的无向图G，vexs为顶点信息，arcs为边信息 */

#include "allinclude.h"  //DO NOT edit this line
Status CreateUDG(ALGraph &G, VexType *vexs, int n, ArcInfo *arcs, int e){ 
    // Add your code here

    int i,j,k,m;
    AdjVexNode *p,*q;
    
    G.n = n;
    G.e = e;

    G.tags = (int *)malloc(n*sizeof(int));
    
    for(m = 0;m < n;m++){
      
      G.tags[m] = UNVISITED;
      G.vexs[m].data = vexs[m];
      G.vexs[m].firstArc = NULL;//别漏了这个初始化！
    }
    
    for(k = 0;k < e;k++){
      
      i = LocateVex(G,arcs[k].v);
      j = LocateVex(G,arcs[k].w);
      
      if(i < 0||j < 0) return ERROR;//假若i，j不存在
      
      p = (AdjVexNode *)malloc(sizeof(AdjVexNode));
      if(!p) return OVERFLOW;
      p->adjvex = j;
      p->next = G.vexs[i].firstArc;
      G.vexs[i].firstArc = p;
      
      q = (AdjVexNode *)malloc(sizeof(AdjVexNode));
      if(!q) return OVERFLOW;
      q->adjvex = i;
      q->next = G.vexs[j].firstArc;
      G.vexs[j].firstArc = q;
    }
    
    return OK;
}
輝长六加1
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
文献学习(part8)--A community detection algorithm based on graph compression...
小山羊的学习日志
11-24 469
学习笔记，仅供参考，有错必纠 文章目录A community detection algorithm based on graph compression for large-scale social networks摘要介绍相关工作提出的社区检测算法 A community detection algorithm based on graph compression for large-scale social networks 一种基于图形压缩的大规模社交网络社区检测算法 摘要 揭示社会网络的底层社
广东工业大学 数据结构 anyview 作业系统 第七章答案
11-18
广东工业大学 数据结构 anyview 作业系统 第七章答案
Anyview第七章答案
weixin_51477091的博客
01-27 1005
CP07EX103 /********** 【习题7.103】编写函数，求整数m和n的最大公约数， 并作为函数的返回值。 **********/ #include "allinclude.h" int gdc6875(int m, int n) { int i, t; for (i = 1; i <= m && i <= n; i++) { if (m % i == 0 && n % i == 0) t.
广工anyview数据结构第七章(2021.12)
凛_Lin~~的博客
01-21 3330
广工anyview数据结构第七章习题，代码非最优解，仅供参考
广工 AnyviewC C语言习题 第七章
雁过留痕的博客
12-31 6698
Anyview 第七章 标签（空格分隔）： C语言 /********** ##【习题7.010】写一函数求3个整数中最小的数。 **********/ int min(int x, int y, int z) /* 返回3个整数x,y和z中最小的数 */ { int min=x; if (y&amp;lt;min) { min=y; } if (z&amp;lt;min) { min=z;...
广东工业大学数据结构anyview代码第八章
最新发布
01-25
第八章的练习涵盖了图的构建、遍历以及修改等操作。以下是根据给定的代码片段解析出的相关知识点： 1. **图的基本概念**： 图是一种非线性的数据结构，由顶点（Vertex）和边（Edge）组成，可以用来表示对象之间的...
广东工业大学数据结构anyview代码第七章
01-25
这些代码片段来自于广东工业大学数据结构课程的一系列练习题目，涉及到了树形数据结构的基本操作和算法。以下是每个代码段对应的知识点详解： 1. **DC07PE15 - 删除叶子节点** 这个函数`Leave(CSTree T)`实现了...
广东工业大学数据结构anyview代码第一章
01-25
广东工业大学数据结构anyview代码第一章 本资源摘要信息对应的是广东工业大学数据结构课程的anyview代码第一章，以下是对该资源的详细说明和知识点总结。 标题解释 该资源的标题为“广东工业大学数据结构anyview...
广东工业大学数据结构anyview代码第二章
01-25
广东工业大学的数据结构课程是计算机科学与技术专业的重要基础课程，主要涵盖了数据的组织、存储和操作方法。在第二章的学习中，通常会涉及到一系列的核心概念和算法，这些内容对于理解和解决实际编程问题至关重要。...
广工 AnyviewC C语言习题 第九章
雁过留痕的博客
12-31 5253
Anyview 第九章 /********** 【习题9.023】结构体类型定义如下： struct date{int year; int month; int day;}; //定义日期结构体类型 struct student { char name[20]; struct date birth; //出生日期 }; 结构体数组s存储了n个人的名字和出生日期。写一函数，求这n个人中...
广工 离散Anyview上机答案完整版
01-16
广工 离散Anyview上机答案完整版
广工anyview数据结构答案
05-08
广东工业大学数据结构anyview答案，对于广工的学子来说是很好的参考读物，方便大家完成作业的同时，完善自己写的代码！
广工数据结构anyview答案20150518(已更新）
05-19
鉴于前几次更新之后都没有人下载，所以现在把资源分给调低一点，希望有需要的同学不要在意那点资源分啦。
广东工业大学题目详解（含截图）AnyviewC
07-09
广工anyview习题答案，题目详解。详细截图。可通过运行。
树（孩子—兄弟链表表示）
04-08
已知一颗树的由根至叶子结点按层次输入的结点序列及每个结点的度（每层中自左至右输入），试写出构造此树的孩子—兄弟链表的算法
二叉树：在孩子兄弟链表表示的树中求叶子节点的个数
乐行僧的博客
11-24 7100
typedef struct CSNode { int val; CSNode *firstchild, *nextsibling; } CSNode, *CSTree; int dfs(CSTree *root) { if (!root) return 0; else if (!root->firstchild) return 1; else { int le...
[树] 树的基本操作（孩子兄弟结点CSTree | 二叉树存储） -- 叶子结点个数|树的度|树的深度|打印树的边（严蔚敏《数据结构》6.59-6.62）
geodoer
10-05 2062
题目来源：严蔚敏《数据结构》C语言版本习题册 6.59-6.62 【题目】6.59 编写算法完成下列操作：无重复地输出以孩子-兄弟链表存储的树T中所有的边。输出的形式为(k1, k2), …, (ki, kj), …,其中，ki和kj为树结点中的结点标识。 【题目】6.60 试编写算法，对一棵以孩子-兄弟链表表示的树统计叶子的个数。 【题目】6.61 试编写算法，求一棵以孩子-兄弟链表表示的树...
求 以孩子-兄弟链表表示的树 的度、深度、叶结点和边
热门推荐
Feynman1999的博客
05-26 2万+
孩子兄弟表示法 任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。因此，我们设置两个指针，分别指向该结点的第一个孩子和此结点的右兄弟。 //其结构可定义为 typedef struct CSNode{ char data; struct CSNode* firstchild; struct CSNode* nextsibling; }CSNode,*C
广东工业大学数据结构第二章Anyview练习代码解析
"这些代码是广东工业大学数据结构课程中关于栈操作的部分练习，涉及了创建、初始化、检查栈是否为空、获取栈顶元素以及出栈等基本操作。" 在数据结构中，栈是一种非常重要的线性数据结构，遵循“后进先出”（Last ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值