广工anyview数据结构-09~10（乱码不贴）

最新推荐文章于 2023-03-21 16:03:49 发布
最新推荐文章于 2023-03-21 16:03:49 发布
阅读量3.5k 收藏 5
点赞数 1
分类专栏： 广工anyview数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clr_lr/article/details/46829003
版权
这篇博客介绍了如何在不同的数据结构表示的树中计算节点的度和树的深度。提供了针对孩子兄弟链表、双亲表示法、双亲孩子链表表示的树的深度计算算法。此外，还涵盖了如何构造孩子兄弟链表树、并查集查找操作的非递归实现、有向图邻接数组存储结构的创建以及邻接表存储结构的相关操作，如顶点出度和入度的计算。
摘要由CSDN通过智能技术生成
/**********
【题目】试编写算法，对一棵以孩子兄弟链表表示
的树统计叶子的个数。
孩子兄弟链表类型定义：
typedef struct CSTNode {
  TElemType  data;
  struct CSTNode  *firstChild, *nextSibling;
} CSTNode, *CSTree;
**********/
int Leave(CSTree T) /* 统计树T的叶子数 */
{
  int count=0;
  if(!T) return 0;
  if(!T->firstChild) count=1;
  if(T->firstChild) count+=Leave(T->firstChild);
  if(T->nextSibling) count+=Leave(T->nextSibling);
  return count;

}




/**********
【题目】试编写算法，求一棵以孩子兄弟链表表示的树的度。
孩子兄弟链表类型定义：
typedef struct CSTNode {
  TElemType  data;
  struct CSTNode  *firstChild, *nextSibling;
} CSTNode, *CSTree;
**********/


void CountDegree(CSTree T,int &count,int &max)
{
 int ChildCount=1;
 if(T->nextSibling) 
  {
   count++;
   CountDegree(T->nextSibling,count,max);
   if(count>max) max=count;
  }
 if(T->firstChild)
 {
   CountDegree(T->firstChild,ChildCount,max);
   if(ChildCount>max) max=ChildCount;
 }
 
}


int Degree(CSTree T) /* 求树T的度 */
{
 int count=1,max=1;
 if(!T) return 0;
 CountDegree(T,count,max);
 return max;
}




/**********
【题目】试编写算法，对以双亲表示法存储的树计算深度。
typedef struct {
  TElemType data;
  int     parent;  // 双亲位置
} PTNode; // 结点类型
typedef struct {
  PTNode nodes[MAX_TREE_SIZE]; // 结点存储空间
  int  n, r; // 结点数和根的位置
} PTree;
**********/
int PTreeDepth(PTree T) /* 求树T的深度 */
{
 int MaxDepth=1,CurDepth=0,i;
 PTNode temp;
 for(i=1;i<=T.n-1;i++)
  {
    CurDepth=1;
    temp=T.nodes[i];
    while(temp.parent!=T.r)
      {
        CurDepth++;
        temp=T.nodes[temp.parent];
      }
    if(CurDepth+1>MaxDepth) MaxDepth=CurDepth+1;
  }
  return MaxDepth; 
}





/**********
【题目】试编写算法，对以双亲孩子表示法存储的树计算深度。
孩子链表类型定义：
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的深度 */
{
    int max=0,dep,m;
    int i;
    int Index;
    ChildNode *child,*childc;
    if(!T.nodes[T.r].firstChild)return 1;
    for(childc=T.nodes[T.r].firstChild;childc;childc=childc->nextChild){
        dep = 1;
        Index=childc->childIndex;
        child=childc;
        while(child){            
            child=T.nodes[Index].firstChild;
            Index=child->childIndex;
            dep++;
        }
        if(max<dep) max = dep;
    }
    return max;
}






/**********
【题目】试编写算法，对以孩子-兄弟链表表示的树计算深度。
孩子兄弟链表类型定义：
typedef struct CSTNode {
  TElemType  data;
  struct CSTNode  *firstChild, *nextSibling;
} CSTNode, *CSTree;
**********/
int TreeDepth(CSTree T)
/* 求树T的深度 */
{
   int maxd=0,d;
   CSTree p;
   if(!T)return 0;
   if(!T->firstChild)return 1;
   for(p=T->firstChild;p;p=p->nextSibling){
     d=TreeDepth(p);
     if(d>maxd)maxd=d;
   }
   return maxd+1;
}




/**********
【题目】已知一棵树的由根至叶子结点按层次输出的
结点序列及每个结点的度。试编写算法，构造此树的
孩子兄弟链表。
孩子兄弟链表类型定义：
typedef struct CSTNode {
  TElemType  data;
  struct CSTNode  *firstChild, *nextSibling;
} CSTNode, *CSTree;
**********/
CSTNode* searchTree(CSTree T,char x)
/* 在树T中查找x */
{
    CSTree temp1,temp2;
    if(T==NULL)return NULL;
    if(T->data==x)return T;
    else
    {
       temp1=searchTree(T->firstChild,x);
       temp2=searchTree(T->nextSibling,x);
       if(temp1!=NULL)
            return temp1;
       else if(temp2!=NULL)
            return temp2;
       else 
            return NULL;
    }
}


void BuildCSTree(CSTree &T, char *node, int *degree)
/* 由结点的层序序列node和各结点的度degree构造树的孩子兄弟链表T */
{  
  int child=0,index=1,i=0,k=0;
  CSTNode *p,*q,*temp;
  
  q=(CSTNode *)malloc(sizeof(CSTNode));
  q->firstChild=NULL;
  q->nextSibling=NULL;
  q->data=node[0];
  T=q;
  temp=q;
  while(node[i]!='\0')
  {   
        q=temp;       
        child=degree[i];    
        for(int j=0;j<child;j++)
        {
            p=(CSTNode *)malloc(sizeof(CSTNode));
            p->firstChild=NULL;
            p->nextSibling=NULL;
            p->data=node[index++];
            if(j==0)
            {
                q->firstChild=p;
                q=q->firstChild;
            }
            else
            {
                q->nextSibling=p;
                q=q->nextSibling;
            }
        }
        i++; 
        temp=searchTree(T,node[i]);
        if(temp==NULL)break;
  }
}





/**********
【题目】试编写非递归算法，实现并查集带路径压缩的
查找操作。
并查集的类型定义如下：
typedef struct {
  int *parent;
  int  n;
} MFSet;
**********/
int find(MFSet S, int i) 
/* 并查集带路径压缩的查找的非递归实现 */
{
    int k, j, r;
    r = i;
    while(S.parent[r]>=0)     //查找根节点
        r = S.parent[r];      //找到根节点，用r记录下
    k = i;
    while(k != r)             //非递归路径压缩操作
    {
        j = S.parent[k];         //用j暂存parent[k]的父节点
        S.parent[k] = r;        //parent[x]指向根节点
        k = j;                    //k移到父节点
    }
    return r;         //返回根节点的值    
}




/**********
【题目】编写算法，创建有向图的邻接数组存储结构。
//图的邻接数组存储结构的类型定义如下：
#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]; // 关系数组，对无权图，用0或1表示相邻否，
              // 对带权图，则为权值或INFINITY
  VexType vexs[MAX_VEX_NUM]; // 顶点数组
  int n, e;   // 顶点数和边（弧）数
  GraphKind kind; // 图的类型
  //int *tags;  // 标志数组，可用于在图的遍历中标记顶点访问与否
} 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为边信息 */
{
    InitGraph(G,DG,n);
    G.n=n;
    int k1,k2;
    for(int i=0;i<n;i++){
        G.vexs[i]=vexs[i];
    }
    G.e=e;
    
    for(i=0;i<e;i++){
        k1=LocateVex(G,arcs[i].v);
        k2=LocateVex(G,arcs[i].w);
        G.arcs[k1][k2].adj=1;
    }
}




/**********
【题目】编写算法，在图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顶点，求下一个邻接顶点 */
{
  int i;
  if(G.n==0&&k==0&&m==0) return 0;
  for(i=m+1;i<G.n;i++)
        if(G.arcs[k][i].adj!=0)
            return i;


  return -1;
}





/**********
【题目】编写算法，在图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的弧或边 */
{
    int i,j,k;
    VRType *p;    
    i=LocateVex(G,v);
    j=LocateVex(G,w);    
    if(i<0||j<0||v==w) return ERROR;
    else if(G.arcs[i][j].adj!=info.adj){
     G.e++;
     G.arcs[i][j]=info;
    } 
    return OK;      


}





/**********
【题目】编写算法，计算以邻接表方式存储的有向图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 */
{
   int i,outD=0,j;
   AdjVexNode *p;
   if(k<0||k>=G.n) return -1;
   p=G.vexs[k].firstArc;
   while(p!=NULL){
      outD++;
      p=p->next;
   }
   
  return outD;
   
}





/**********
【题目】编写算法，计算以邻接表方式存储的有向图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 */
{
   AdjVexNode *p;
   if(k<0||k>G.n) return -1;
   int degree[20];
   int i;
    for(i=0;i<G.n;i++){
        degree[i]=0;
    }
    for(i=0;i<G.n;i++){
       while(G.vexs[i].firstArc){
         degree[G.vexs[i].firstArc->adjvex]++;
         G.vexs[i].firstArc=G.vexs[i].firstArc->next;
        }
    }
   return degree[k];
}






/**********
【题目】编写算法，创建有向图的邻接表存储结构。
图的邻接表存储结构的类型定义如下：
#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为边信息 */
{
   int i,j,k;
   VexType v,w;
   AdjVexNodeP p;
   G.n=n;G.e=e;
  // G.vexs=(VexNode*)malloc(sizeof(VexNode)*n);
   G.tags=(int*)malloc(sizeof(int)*n);
   for(i=0;i<G.n;i++)
     {  G.tags[i]=UNVISITED;
        G.vexs[i].data=vexs[i];
        G.vexs[i].firstArc=NULL;
     }
    for(k=0;k<G.e;k++)
      {  v=arcs[k].v;w=arcs[k].w;
         i=LocateVex(G,v);j=LocateVex(G,w);
         if(i<0||j<0) return ERROR;
         p=(AdjVexNode*)malloc(sizeof(AdjVexNode));
         if(NULL==p)  return OVERFLOW;
         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为边信息 */
{
    int i,j,k;
    VexType v,w;
    AdjVexNode *p;
    G.n=n;G.e=e;
    G.kind=UDG; 
    for(i=0;i<G.n;i++){
        G.tags[i]=0;
        G.vexs[i].data= vexs[i];
        G.vexs[i].firstArc=NULL;        
    }
    for(k=0;k<G.e;k++){
        v=arcs[k].v;
        w=arcs[k].w;
        i=LocateVex(G,v);
        j=LocateVex(G,w);
        if(i<0||j<0) return ERROR;
        p=(AdjVexNode*)malloc(sizeof(AdjVexNode));
        p->adjvex=j;
        p->next=G.vexs[i].firstArc;
        G.vexs[i].firstArc=p;
        
        p=(AdjVexNode*)malloc(sizeof(AdjVexNode));
        p->adjvex=i;
        p->next=G.vexs[j].firstArc;
        G.vexs[j].firstArc=p;
    }
    return OK;
}


clr_lr
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
广工anyview数据结构第1章
weixin_45432844的博客
11-29 597
第一章 PE06 /********** 【题目】试写一算法，如果三个整数a，b和c的值 不是依次非递增的，则通过交换，令其为非递增。 ***********/ void Descend(int &a, int &b, int &c) /* 通过交换，令 a >= b >= c */ { int t; if( a< b) { ...
广工anyview数据结构第八章(2021.12)
凛_Lin~~的博客
01-21 2887
广工anyview数据结构第八章习题，代码非最优解，仅供参考
广工 AnyviewC C语言习题 第八章
雁过留痕的博客
12-31 5096
Anyview 第八章 指针 /********** 【习题8.011】请编写函数func(char s[], char t[], int n)， 由数组s中长度为n的字符序列构造其逆序列，并存储在数组t中。 例如，由给定字符序列s="are"求得逆序列t=“era”；由s=“time” 求得t=“emit”。 **********/ void func(char s[], char t[], ...
广东工业大学 数据结构 anyview 作业系统 第七章答案
11-18
广东工业大学 数据结构 anyview 作业系统 第七章答案
广工anyview数据结构-7
geek_jerome的博客
01-18 1255
/**** 【题目】若两棵二叉树T1和T2皆为空，或者皆不空 且T1的左、右子树和T2的左、右子树分别相似，则 称二叉树T1和T2相似。试编写算法，判别给定两棵 二叉树是否相似。 二叉链表类型定义： typedef struct BiTNode { TElemType data; struct BiTNode *lchild, *rchild; } BiTNode,
2016广工AnyView数据结构-第1-5章答案.pdf
最新发布
11-24
"2016广工AnyView数据结构-第1-5章答案.pdf" 本文档总结了数据结构的基本概念和算法实现，涵盖了五个问题，分别是： 一、交换三个整数的值使其非递增排序 这个问题的算法实现了交换三个整数的值，使其非递增排序...
广工anyview数据结构答案
05-08
广东工业大学数据结构anyview答案，对于广工的学子来说是很好的参考读物，方便大家完成作业的同时，完善自己写的代码！
广东工业大学数据结构anyview代码第一章
01-25
广东工业大学数据结构anyview代码第一章 本资源摘要信息对应的是广东工业大学数据结构课程的anyview代码第一章，以下是对该资源的详细说明和知识点总结。 标题解释 该资源的标题为“广东工业大学数据结构anyview...
广东工业大学数据结构anyview代码第二章
01-25
广东工业大学的数据结构课程是计算机科学与技术专业的重要基础课程，主要涵盖了数据的组织、存储和操作方法。在第二章的学习中，通常会涉及到一系列的核心概念和算法，这些内容对于理解和解决实际编程问题至关重要。...
广工数据结构anyview答案20150518(已更新）
05-19
鉴于前几次更新之后都没有人下载，所以现在把资源分给调低一点，希望有需要的同学不要在意那点资源分啦。
广工Anyview数据结构答案
06-12
广工Anyview数据结构答案. 可供给大家的anyview提供参考！
广工2015数据结构Anyview答案
06-30
广工2015数据结构Anyview答案
广工版anyview数据结构上机答案
05-30
广工版anyview的数据结构的上机答案，基本上都有了，只有个别的没有！！
广工AnyView数据结构-4
geek_jerome的博客
10-27 1695
/**** 【题目】已知某哈希表的装载因子小于1，哈希函数H(key) 为关键字(标识符)的第一个字母在字母表中的序号，处理 冲突的方法为线性探测开放定址法。试编写一个按第一个 字母的顺序输出哈希表中所有关键字的算法。 哈希表的类型HashTable定义如下：define SUCCESS 1define UNSUCCESS 0define DUPLICATE -1typedef c
广工AnyView数据结构-3
geek_jerome的博客
10-27 1526
/**** 【题目】试以顺序表L的L.rcd[L.length+1]作为监视哨， 改写教材3.2节中给出的升序直接插入排序算法。 顺序表的类型RcdSqList定义如下： typedef struct { KeyType key; … } RcdType; typedef struct { RcdType rcd[MAXSIZE+1]; // rcd[0]闲置
anyview-数据结构
Young77775的博客
03-21 1017
数据结构第一章 第一章
广工Anyview数据结构2021-C语言版--第一章
m0_53106380的博客
09-13 997
第一章 eg1： 算法思考： //首先随机比较三选二 /* 算法实现原理： 若a<b,则交换a，b，使得a>b,进而继续比较a、c，若a<c,则交换a，c使得a>c，此时有a>b&&a>c. 接着，比较b、c大小即可得到a >= b >= c */ PS：本人菜鸟一枚，欢迎各位大佬与我共同探讨更多思路~。 ...
广东工业大学数据结构第六章Anyview练习代码解析
"广东工业大学数据结构anyview代码第六章" 这些代码是广东工业大学数据结构课程的一份练习，主要涉及数据结构中的二叉树部分。在这一章中，学生们被要求实现一系列与二叉树相关的算法问题。以下是部分练习的概述： ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值