AnyView DC07-08

作者: kekxy | 来源:发表于2020-12-18 12:36 被阅读0次

AnyView DC07-08
UIscrollView 自动布局 Masonry
Java学习资料汇总（一）
安卓阅读app智能导书功能分析
AnyView DC01-04
AnyView DC05-06
关于微信读书
SwiftUI Tips: AnyView 的使用场景
记一次对Anyview阅读iOS版wifi传书功能的抹黑探索
时光与你。若即若离。

/**********
【题目】试编写算法，对一棵以孩子兄弟链表表示
的树统计叶子的个数。
孩子兄弟链表类型定义：
typedef struct CSTNode {
  TElemType  data;
  struct CSTNode  *firstChild, *nextSibling;
} CSTNode, *CSTree;
**********/
int Leave(CSTree T) /* 统计树T的叶子数 */
{
    if(!T) return 0;
    int lf=1;
    if(T->firstChild) lf+=Leave(T->firstChild)-1;
    if(T->nextSibling) lf+=Leave(T->nextSibling);
    return lf;
}


/**********
【题目】试编写算法，求一棵以孩子兄弟链表表示的树的度。
孩子兄弟链表类型定义：
typedef struct CSTNode {
  TElemType  data;
  struct CSTNode  *firstChild, *nextSibling;
} CSTNode, *CSTree;
**********/
int Degree(CSTree T) /* 求树T的度 */
{    
    int ma=0,mb=0,mc=0;
    if(T->firstChild)
    {
        ma=Degree(T->firstChild);
        CSTree x=T->firstChild;        
        while(x)
        {
            ++mc;
            mb=Degree(x);
            if(mb>ma) ma=mb;
            x=x->nextSibling;                        
        }
    }
    if(ma>mc) mc=ma;
    return mc;
}


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


/**********
【题目】试编写算法，对以双亲孩子表示法存储的树计算深度。
孩子链表类型定义：
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 getd(PCTree *S,PCTreeNode *x)
{
    int ma=1,mb=0;
    ChildNode *now=x->firstChild;
    if(now)
    {
        ma=getd(S,S->nodes+now->childIndex)+1;
        while(now->nextChild)
        {
            now=now->nextChild;
            mb=getd(S,S->nodes+now->childIndex)+1;
            if(mb>ma) ma=mb;
        }        
    }    
    return ma; 
}

int PCTreeDepth(PCTree T) /* 求树T的深度 */
{
    return getd(&T,T.nodes+T.r);
}


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


/**********
【题目】已知一棵树的由根至叶子结点按层次输出的
结点序列及每个结点的度。试编写算法，构造此树的
孩子兄弟链表。
孩子兄弟链表类型定义：
typedef struct CSTNode {
  TElemType  data;
  struct CSTNode  *firstChild, *nextSibling;
} CSTNode, *CSTree;
**********/
void BuildCSTree(CSTree &T, char *node, int *degree)
/* 由结点的层序序列node和各结点的度degree构造树的孩子兄弟链表T */
{
    int L=0,i;
    CSTNode *tc;
    tc=(CSTNode*)malloc(sizeof(CSTNode)*25);
    for(i=0;i<25;++i) tc[i].firstChild=tc[i].nextSibling=NULL;
    for(i=0;node[i]!='\0';++i)
    {
        tc[i].data=node[i];
        if(degree[i])
        {
            CSTree now=NULL;
            for(int j=1;j<=degree[i];++j)
            {
                ++L;
                if(!tc[i].firstChild) tc[i].firstChild=now=(tc+L);
                else now->nextSibling=(tc+L),now=tc+L;
            }
        }
    }
    T=tc;
}


/**********
【题目】试编写非递归算法，实现并查集带路径压缩的
查找操作。
并查集的类型定义如下：
typedef struct {
  int *parent;
  int  n;
} MFSet;
**********/
int find(MFSet S, int i) 
/* 并查集带路径压缩的查找的非递归实现 */
{
    //return (S.parent[i]<0)?(i):(S.parent[i]=find(S,S.parent[i]));
    int stack[25],L=0;
    while(S.parent[i]>=0)
    {
        stack[L++]=i;
        i=S.parent[i];
    }
    for(int j=1;j<=L;++j) S.parent[stack[j-1]]=i;
    return i;
}


/**********
【题目】编写算法，创建有向图的邻接数组存储结构。
图的邻接数组存储结构的类型定义如下：
#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为边信息 */
{
    int i; InitGraph(G,DG,n);
    G.n=n; G.e=e;
    for(i=0;i<n;++i) G.vexs[i]=vexs[i];
    for(i=0;i<e;++i)
    {
        int v=LocateVex(G,arcs[i].v);
        int w=LocateVex(G,arcs[i].w);
        G.arcs[v][w].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顶点，求下一个邻接顶点 */
{
    if(G.n==0 || G.e==0) return 0;
    for(int i=m+1;i<G.n;++i)
    if(G.arcs[k][i].adj) 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 x=LocateVex(G,v);
    int y=LocateVex(G,w);
    if(x==y || x<0 || y<0) return ERROR;
    if(!G.arcs[x][y].adj) G.e++,G.arcs[x][y]=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 s=0;
    if(k<0 || k>=G.n) return -1;
    for(AdjVexNodeP p=G.vexs[k].firstArc;p;p=p->next) ++s;
    return s;                       
}

/**********
【题目】编写算法，计算以邻接表方式存储的有向图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 */
{
    if(k<0 || k>=G.n) return -1;
    int dg[25],i;
    for(i=0;i<25;++i) dg[i]=0;
    for(i=0;i<G.n;++i)
    {
        for(AdjVexNodeP p=G.vexs[i].firstArc;p;p=p->next)
        dg[p->adjvex]++;
    }
    return dg[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为边信息 */
{
    G.n=n; G.e=e; G.kind=DG; 
    int i; AdjVexNodeP p;
    G.tags=(int*)malloc(sizeof(int)*n);
    for(i=0;i<n;++i)
    {
        G.tags[i]=UNVISITED;
        G.vexs[i].data=vexs[i];
        G.vexs[i].firstArc=NULL;
    }
    for(i=0;i<e;++i)
    {
        int v=LocateVex(G,arcs[i].v);
        int w=LocateVex(G,arcs[i].w);
        if(v<0 || w<0 || v>=n || w>=n) return ERROR;
        p=(AdjVexNode*)malloc(sizeof(AdjVexNode));       
        p->adjvex=w;
        p->next=G.vexs[v].firstArc;
        G.vexs[v].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为边信息 */
{
    G.n=n; G.e=e; G.kind=DG; 
    int i; AdjVexNodeP p;
    G.tags=(int*)malloc(sizeof(int)*n);
    for(i=0;i<n;++i)
    {
        G.tags[i]=UNVISITED;
        G.vexs[i].data=vexs[i];
        G.vexs[i].firstArc=NULL;
    }
    for(i=0;i<e;++i)
    {
        int v=LocateVex(G,arcs[i].v);
        int w=LocateVex(G,arcs[i].w);
        if(v<0 || w<0 || v>=n || w>=n) return ERROR;
        //v->w
        p=(AdjVexNode*)malloc(sizeof(AdjVexNode));       
        p->adjvex=w;
        p->next=G.vexs[v].firstArc;
        G.vexs[v].firstArc=p;
        //w->v
        p=(AdjVexNode*)malloc(sizeof(AdjVexNode));       
        p->adjvex=v;
        p->next=G.vexs[w].firstArc;
        G.vexs[w].firstArc=p;
    }
    return OK;
}

AnyView DC07-08
UIscrollView 自动布局 Masonry
add scroll scroll add contentView contentView add anyView
Java学习资料汇总（一）
anyview4.11.java源代码.rar： https://www.baiyu.tech/v/d/1F...
安卓阅读app智能导书功能分析
分析的产品：iReader，qq阅读，书旗，多看，追书神器，塔读，91，起点，开卷有益，阅读星，Anyview，天...
AnyView DC01-04
AnyView DC05-06
关于微信读书
曾经用过不少电子阅读的app，如掌阅、anyview、网易蜗牛读书等等，还是觉得微信读书最好用。首先，微信读书里...
SwiftUI Tips: AnyView 的使用场景
SwiftiUI 提供了一个结构体 AnyView来表示任意一个 View 实例，和 Any 一样可以用来抹除具体...
记一次对Anyview阅读iOS版wifi传书功能的抹黑探索
记一次对Anyview阅读iOS版wifi传书功能的抹黑探索原因由于我最习惯使用的看小说的软件是 Anyvie...
时光与你。若即若离。
「一。」八月二十七号零点零分，手机模式切换到飞行模式，习惯性的点开了anyview阅读，自动打开到上次的内容，酒徒...