❶ 廣義表的深度如何理解
廣義表的"深度"是指表展開後所含括弧的層數。
廣義表的深度的求法為每個元素的括弧匹配數加1的最大值。
以廣義表(a,(a,b),d,e,((i,j),k))為例：
a為1+0=1;
(a,b)為1+1=2;
d,e類似;
((i,j),k)為2+1=3;
故深度為3。
(1)廣義表擴展存儲求深度擴展閱讀：
廣義表中放鬆對表元素的原子限制，容許它們具有其自身結構。它被廣泛的應用於人工智慧等領域的表處理語言LISP語言中。在LISP語言中，廣義表是一種最基本的數據結構，就連LISP 語言的程序也表示為一系列的廣義表。
廣義表的長度的求法為最大括弧中的逗號數加1。
同樣以廣義表(a,(a,b),d,e,((i,j),k))為例：
a後面的逗號，
(a,b)後面的逗號，
d後面的逗號，
e後面的逗號，((i,j),k)前面的逗號，
總計有四個，那麼廣義表的長度是4+1=5。
參考資料：網路-廣義表
❷ 廣義表的長度和深度怎麼算
廣義表的長度，指的是廣義表中所包含的數據元素的個數。
由於廣義表中可以同時存儲原子和子表兩種類型的數據，因此在計算廣義表的長度時規定，廣義表中存儲的每個原子算作一個數據，同樣每個子表也只算作是一個數據。
廣義表的深度，可以通過觀察該表中所包含括弧的層數間接得到。
❸ 怎麼寫廣義表的存儲結構圖
廣義表的存儲結構代碼:
/* c5-5.h 廣義表的頭尾鏈表存儲表示 */
typedef enum{ATOM,LIST}ElemTag; /* ATOM==0：原子，LIST==1：子表 */
typedef struct GLNode
{
ElemTag tag; /* 公共部分，用於區分原子結點和表結點 */
union /* 原子結點和表結點的聯合部分 */
{
AtomType atom; /* atom是原子結點的值域，AtomType由用戶定義 */
struct
{
struct GLNode *hp,*tp;
}ptr; /* ptr是表結點的指針域，prt.hp和ptr.tp分別指向表頭和表尾 */
}a;
}*GList,GLNode; /* 廣義表類型 */
廣義表的存儲結構圖:
❹ 廣義表基本運算（建立、查找、求表頭、求表尾、深度）
/* bo5-6.c 廣義表的擴展線性鏈表存儲(存儲結構由c5-6.h定義)的基本操作(13個) */
#include"c4-2.h" /* 定義HString類型 */
#include"bo4-2.c" /* HString類型的基本操作 */
/* 廣義表的書寫形式串為HString類型 */
Status InitGList(GList *L)
{ /* 創建空的廣義表L */
*L=NULL;
return OK;
}
Status sever(HString *str,HString *hstr) /* 同bo5-52.c */
{ /* 將非空串str分割成兩部分:hstr為第一個','之前的子串,str為之後的子串 */
int n,i=1,k=0; /* k記尚未配對的左括弧個數 */
HString ch,c1,c2,c3;
InitString(&ch); /* 初始化HString類型的變數 */
InitString(&c1);
InitString(&c2);
InitString(&c3);
StrAssign(&c1,",");
StrAssign(&c2,"(");
StrAssign(&c3,")");
n=StrLength(*str);
do
{
SubString(&ch,*str,i,1);
if(!StrCompare(ch,c2))
++k;
else if(!StrCompare(ch,c3))
--k;
++i;
}while(i<=n&&StrCompare(ch,c1)||k!=0);
if(i<=n)
{
StrCopy(&ch,*str);
SubString(hstr,ch,1,i-2);
SubString(str,ch,i,n-i+1);
}
else
{
StrCopy(hstr,*str);
ClearString(str);
}
return OK;
}
Status CreateGList(GList *L,HString S)
{ /* 初始條件: S是廣義表的書寫形式串。操作結果: 由S創建廣義表L */
HString emp,sub,hsub;
GList p;
InitString(&emp);
InitString(&sub);
InitString(&hsub);
StrAssign(&emp,"()"); /* 設emp="()" */
*L=(GList)malloc(sizeof(GLNode));
if(!*L) /* 建表結點不成功 */
exit(OVERFLOW);
if(!StrCompare(S,emp)) /* 創建空表 */
{
(*L)->tag=LIST;
(*L)->a.hp=NULL;
(*L)->tp=NULL;
}
else if(StrLength(S)==1) /* 創建單原子廣義表 */
{
(*L)->tag=ATOM;
(*L)->a.atom=S.ch[0];
(*L)->tp=NULL;
}
else /* 創建一般表 */
{
(*L)->tag=LIST;
(*L)->tp=NULL;
SubString(&sub,S,2,StrLength(S)-2); /* 脫外層括弧 */
sever(&sub,&hsub); /* 從sub中分離出表頭串hsub */
CreateGList(&(*L)->a.hp,hsub);
p=(*L)->a.hp;
while(!StrEmpty(sub)) /* 表尾不空,則重復建n個子表 */
{
sever(&sub,&hsub); /* 從sub中分離出表頭串hsub */
CreateGList(&p->tp,hsub);
p=p->tp;
};
}
return OK;
}
void DestroyGList(GList *L)
{ /* 初始條件: 廣義表L存在。操作結果: 銷毀廣義表L */
GList ph,pt;
if(*L) /* L不為空表 */
{ /* 由ph和pt接替L的兩個指針 */
if((*L)->tag) /* 是子表 */
ph=(*L)->a.hp;
else /* 是原子 */
ph=NULL;
pt=(*L)->tp;
free(*L); /* 釋放L所指結點 */
*L=NULL; /* 令L為空 */
DestroyGList(&ph); /* 遞歸銷毀表ph */
DestroyGList(&pt); /* 遞歸銷毀表pt */
}
}
Status CopyGList(GList *T,GList L)
{ /* 初始條件: 廣義表L存在。操作結果: 由廣義表L復製得到廣義表T */
if(!L) /* L空 */
{
*T=NULL;
return OK;
}
*T=(GList)malloc(sizeof(GLNode));
if(!*T)
exit(OVERFLOW);
(*T)->tag=L->tag; /* 復制枚舉變數 */
if(L->tag==ATOM) /* 復制共用體部分 */
(*T)->a.atom=L->a.atom; /* 復制單原子 */
else
CopyGList(&(*T)->a.hp,L->a.hp); /* 復制子表 */
if(L->tp==NULL) /* 到表尾 */
(*T)->tp=L->tp;
else
CopyGList(&(*T)->tp,L->tp); /* 復制子表 */
return OK;
}
int GListLength(GList L)
{ /* 初始條件: 廣義表L存在。操作結果: 求廣義表L的長度,即元素個數 */
int len=0;
GList p;
if(L->tag==LIST&&!L->a.hp) /* 空表 */
return 0; /* 空表返回0 */
else if(L->tag==ATOM) /* 單原子表 */
return 1;
else /* 一般表 */
{
p=L->a.hp;
do
{
len++;
p=p->tp;
}while(p);
return len;
}
}
int GListDepth(GList L)
{ /* 初始條件: 廣義表L存在。操作結果: 求廣義表L的深度 */
int max,dep;
GList pp;
if(L==NULL||L->tag==LIST&&!L->a.hp)
return 1; /* 空表深度為1 */
else if(L->tag==ATOM)
return 0; /* 單原子表深度為0 */
else /* 求一般表的深度 */
for(max=0,pp=L->a.hp;pp;pp=pp->tp)
{
dep=GListDepth(pp); /* 求以pp為頭指針的子表深度 */
if(dep>max)
max=dep;
}
return max+1; /* 非空表的深度是各元素的深度的最大值加1 */
}
Status GListEmpty(GList L)
{ /* 初始條件: 廣義表L存在。操作結果: 判定廣義表L是否為空 */
if(!L||L->tag==LIST&&!L->a.hp)
return OK;
else
return ERROR;
}
GList GetHead(GList L)
{ /* 初始條件: 廣義表L存在。操作結果: 取廣義表L的頭 */
GList h;
InitGList(&h);
if(!L||L->tag==LIST&&!L->a.hp)
{
printf("\n空表無表頭!");
exit(0);
}
h=(GList)malloc(sizeof(GLNode));
if(!h)
exit(OVERFLOW);
h->tag=L->a.hp->tag;
h->tp=NULL;
if(h->tag==ATOM)
h->a.atom=L->a.hp->a.atom;
else
CopyGList(&h->a.hp,L->a.hp->a.hp);
return h;
}
GList GetTail(GList L)
{ /* 初始條件: 廣義表L存在。操作結果: 取廣義表L的尾 */
GList T;
if(!L)
{
printf("\n空表無表尾!");
exit(0);
}
T=(GList)malloc(sizeof(GLNode));
if(!T)
exit(OVERFLOW);
T->tag=LIST;
T->tp=NULL;
CopyGList(&T->a.hp,L->a.hp->tp);
return T;
}
Status InsertFirst_GL(GList *L,GList e)
{ /* 初始條件: 廣義表存在 */
/* 操作結果: 插入元素e作為廣義表L的第一元素(表頭,也可能是子表) */
GList p=(*L)->a.hp;
(*L)->a.hp=e;
e->tp=p;
return OK;
}
Status DeleteFirst_GL(GList *L,GList *e)
{ /* 初始條件:廣義表L存在。操作結果:刪除廣義表L的第一元素,並用e返回其值 */
if(*L)
{
*e=(*L)->a.hp;
(*L)->a.hp=(*e)->tp;
(*e)->tp=NULL;
}
else
*e=*L;
return OK;
}
void Traverse_GL(GList L,void(*v)(AtomType))
{ /* 利用遞歸演算法遍歷廣義表L */
GList hp;
if(L) /* L不空 */
{
if(L->tag==ATOM) /* L為單原子 */
{
v(L->a.atom);
hp=NULL;
}
else /* L為子表 */
hp=L->a.hp;
Traverse_GL(hp,v);
Traverse_GL(L->tp,v);
}
}
❺ 已知下圖為廣義表的存儲結構圖，寫出該圖的廣義表，並求該廣義表的長度和深度
長度：2
深度：5
❻ 廣義表的長度和深度怎麼求 例如E((a,(a,b),((a,b),c)))
長度為第一層的元素個數（原子和子表都只算一個）
E只有一個元素為子表(a,(a,b),((a,b),c))，因此E的長度為1
深度是子表最大的嵌套次數，原子算0，子表算1
從後看：((a,b),c)))到a或者b有四次嵌套，因此E的深度為4
❼ 廣義表深度怎麼算的
廣義表的深度定義為子表的最大嵌套層數，其中：原子為0，空表為1
❽ 數據結構中。13題那個廣義表它的深度是多少，怎麼算的
廣義表的長度：表中所含元素的個數；深度：定義為廣義表中括弧的重數。1。長度：4分別為原子a和h,子表（b,c,(d,e,f),(),g)和(r,s,t)；深度：3，可以看出右邊中深度最大的是（b,c,(d,e,f),(),g)，則廣義表的深度為它加1。2。長度：4，深度：3至於表頭表尾是這樣定義的：第一個元素是表頭（Head)，其餘元素組成的表是表尾(Tail)。如1中Head(A)=a;Tail(A)=((b,c,(d,e,f),( ),g),h,(r,s,t))
❾ 怎樣計算廣義表的長度和深度(數據結構)
技巧：深度=括弧層數，寬度=第一層的逗號數+1
❿ 廣義表的深度如何理解
推薦回答廣義表的深度簡單的來說是所包含括弧的層數，同級的括弧屬於一個深度，比如說C=（a,(b,c,(d))).
的深度是3，但是C=（a,(b,c）,(d)).的深度是2