func5-1.cpp && bo5-1~bo5-6.cpp s 數組和廣義表 算法

 

1.  // func5-1.cpp 廣義表的書寫形式串爲SString類型，包括算法5.8。bo5-5.cpp和bo5-6.cpp調用
2.  #include"c4-1.h" // 定義SString類型
3.  #include"bo4-1.cpp" // SString類型的基本操作
4.  void sever(SString str,SString hstr) // 算法5.8改。SString是數組，不需引用類型
5.  { // 將非空串str分割成兩部分：hstr爲第一個','之前的子串，str爲之後的子串
6.    int n,k,i; // k記尚未配對的左括號個數
7.    SString ch,c1,c2,c3;
8.    n=StrLength(str); // n爲串str的長度
9.    StrAssign(c1,","); // c1=','
10.    StrAssign(c2,"("); // c2='('
11.    StrAssign(c3,")"); // c3=')'
12.    SubString(ch,str,1,1); // ch爲串str的第1個字符
13.    for(i=1,k=0;i<=n&&StrCompare(ch,c1)||k!=0;++i) // i小於串長且ch不是','
14.    { // 搜索最外層的第一個逗號
15.      SubString(ch,str,i,1); // ch爲串str的第i個字符
16.      if(!StrCompare(ch,c2)) // ch='('
17.        ++k; // 左括號個數+1
18.      else if(!StrCompare(ch,c3)) // ch=')'
19.        --k; // 左括號個數-1
20.    }
21.    if(i<=n) // 串str中存在','，它是第i-1個字符
22.    {
23.      SubString(hstr,str,1,i-2); // hstr返回串str','前的字符
24.      SubString(str,str,i,n-i+1); // str返回串str','後的字符
25.    }
26.    else // 串str中不存在','
27.    {
28.      StrCopy(hstr,str); // 串hstr就是串str
29.      ClearString(str); // ','後面是空串
30.    }
31.  }

1.  // bo5-1.cpp 順序存儲數組(存儲結構由c5-1.h定義)的基本操作(5個)
2.  Status InitArray(Array &A,int dim,...)
3.  { // 若維數dim和各維長度合法，則構造相應的數組A，並返回OK
4.    int elemtotal=1,i; // elemtotal是數組元素總數，初值爲1(累乘器)
5.    va_list ap;
6.    if(dim<1||dim>MAX_ARRAY_DIM)
7.      return ERROR;
8.    A.dim=dim;
9.    A.bounds=(int *)malloc(dim*sizeof(int));
10.    if(!A.bounds)
11.      exit(OVERFLOW);
12.    va_start(ap,dim);
13.    for(i=0;i<dim;++i)
14.    {
15.      A.bounds[i]=va_arg(ap,int);
16.      if(A.bounds[i]<0)
17.        return UNDERFLOW; // 在math.h中定義爲4
18.      elemtotal*=A.bounds[i];
19.    }
20.    va_end(ap);
21.    A.base=(ElemType *)malloc(elemtotal*sizeof(ElemType));
22.    if(!A.base)
23.      exit(OVERFLOW);
24.    A.constants=(int *)malloc(dim*sizeof(int));
25.    if(!A.constants)
26.      exit(OVERFLOW);
27.    A.constants[dim-1]=1;
28.    for(i=dim-2;i>=0;--i)
29.      A.constants[i]=A.bounds[i+1]*A.constants[i+1];
30.    return OK;
31.  }
33.  void DestroyArray(Array &A)
34.  { // 銷燬數組A
35.    if(A.base)
36.      free(A.base);
37.    if(A.bounds)
38.      free(A.bounds);
39.    if(A.constants)
40.      free(A.constants);
41.    A.base= A.bounds=A.constants=NULL;
42.    A.dim=0;
43.  }
45.  Status Locate(Array A,va_list ap,int &off) // Value()、Assign()調用此函數
46.  { // 若ap指示的各下標值合法，則求出該元素在A中的相對地址off
47.    int i,ind;
48.    off=0;
49.    for(i=0;i<A.dim;i++)
50.    {
51.      ind=va_arg(ap,int);
52.      if(ind<0||ind>=A.bounds[i])
53.        return OVERFLOW;
54.      off+=A.constants[i]*ind;
55.    }
56.    return OK;
57.  }
59.  Status Value(ElemType &e,Array A,...) // 在VC++中，...之前的形參不能是引用類型
60.  { // ...依次爲各維的下標值，若各下標合法，則e被賦值爲A的相應的元素值
61.    va_list ap;
62.    int off;
63.    va_start(ap,A);
64.    if(Locate(A,ap,off)==OVERFLOW) // 調用Locate()
65.      return ERROR;
66.    e=*(A.base+off);
67.    return OK;
68.  }
70.  Status Assign(Array A,ElemType e,...) // 變量A的值不變，故不需要&
71.  { // ...依次爲各維的下標值，若各下標合法，則將e的值賦給A的指定的元素
72.    va_list ap;
73.    int off;
74.    va_start(ap,e);
75.    if(Locate(A,ap,off)==OVERFLOW) // 調用Locate()
76.      return ERROR;
77.    *(A.base+off)=e;
78.    return OK;
79.  }

1.  // bo5-2.cpp 三元組稀疏矩陣的基本操作(8個),包括算法5.1
2.  Status CreateSMatrix(TSMatrix &M)
3.  { // 創建稀疏矩陣M
4.    int i,m,n;
5.    ElemType e;
6.    Status k;
7.    printf("請輸入矩陣的行數,列數,非零元素數：");
8.    scanf("%d,%d,%d",&M.mu,&M.nu,&M.tu);
9.    if(M.tu>MAX_SIZE)
10.      return ERROR;
11.    M.data[0].i=0; // 爲以下比較順序做準備
12.    for(i=1;i<=M.tu;i++)
13.    {
14.      do
15.      {
16.        printf("請按行序順序輸入第%d個非零元素所在的行(1～%d),列(1～%d),元素值:",i,M.mu,M.nu);
17.        scanf("%d,%d,%d",&m,&n,&e);
18.        k=0;
19.        if(m<1||m>M.mu||n<1||n>M.nu) // 行或列超出範圍
20.          k=1;
21.        if(m<M.data[i-1].i||m==M.data[i-1].i&&n<=M.data[i-1].j) // 行或列的順序有錯
22.          k=1;
23.      }while(k);
24.      M.data[i].i=m;
25.      M.data[i].j=n;
26.      M.data[i].e=e;
27.    }
28.   return OK;
29.  }
31.  void DestroySMatrix(TSMatrix &M)
32.  { // 銷燬稀疏矩陣M
33.    M.mu=M.nu=M.tu=0;
34.  }
36.  void PrintSMatrix(TSMatrix M)
37.  { // 輸出稀疏矩陣M
38.    int i;
39.    printf("%d行%d列%d個非零元素。/n",M.mu,M.nu,M.tu);
40.    printf("行  列  元素值/n");
41.    for(i=1;i<=M.tu;i++)
42.      printf("%2d%4d%8d/n",M.data[i].i,M.data[i].j,M.data[i].e);
43.  }
45.  void PrintSMatrix1(TSMatrix M)
46.  { // 按矩陣形式輸出M
47.    int i,j,k=1;
48.    Triple *p=M.data;
49.    p++; // p指向第1個非零元素
50.    for(i=1;i<=M.mu;i++)
51.    {
52.      for(j=1;j<=M.nu;j++)
53.        if(k<=M.tu&&p->i==i&&p->j==j) // p指向非零元，且p所指元素爲當前處理元素
54.        {
55.          printf("%3d",p->e); // 輸出p所指元素的值
56.          p++; // p指向下一個元素
57.          k++; // 計數器+1
58.        }
59.        else // p所指元素不是當前處理元素
60.          printf("%3d",0); // 輸出0
61.      printf("/n");
62.    }
63.  }
65.  void CopySMatrix(TSMatrix M,TSMatrix &T)
66.  { // 由稀疏矩陣M複製得到T
67.    T=M;
68.  }
70.  int comp(int c1,int c2)
71.  { // AddSMatrix函數要用到，另加
72.    if(c1<c2)
73.      return -1;
74.    if(c1==c2)
75.      return 0;
76.    return 1;
77.  }
79.  Status AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q)
80.  { // 求稀疏矩陣的和Q=M+N
81.    int m=1,n=1,q=0;
82.    if(M.mu!=N.mu||M.nu!=N.nu) // M、N兩稀疏矩陣行或列數不同
83.      return ERROR;
84.    Q.mu=M.mu;
85.    Q.nu=M.nu;
86.    while(m<=M.tu&&n<=N.tu) // 矩陣M和N的元素都沒處理完
87.    {
88.      switch(comp(M.data[m].i,N.data[n].i))
89.      {
90.        case -1: Q.data[++q]=M.data[m++]; // 將矩陣M的當前元素值賦給矩陣Q
91.         break;
92.        case  0: switch(comp(M.data[m].j,N.data[n].j)) // M、N矩陣當前元素的行相等,繼續比較列
93.                 {
94.                   case -1: Q.data[++q]=M.data[m++];
95.                            break;
96.                   case  0: Q.data[++q]=M.data[m++]; // M、N矩陣當前非零元素的行列均相等
97.                            Q.data[q].e+=N.data[n++].e; // 矩陣M、N的當前元素值求和並賦給矩陣Q
98.                            if(Q.data[q].e==0) // 元素值爲0，不存入壓縮矩陣
99.                              q--;
100.                            break;
101.                   case  1: Q.data[++q]=N.data[n++];
102.                 }
103.                 break;
104.        case  1: Q.data[++q]=N.data[n++]; // 將矩陣N的當前元素值賦給矩陣Q
105.      }
106.    }
107.    while(m<=M.tu) // 矩陣N的元素全部處理完畢
108.      Q.data[++q]=M.data[m++];
109.    while(n<=N.tu) // 矩陣M的元素全部處理完畢
110.      Q.data[++q]=N.data[n++];
111.    Q.tu=q; // 矩陣Q的非零元素個數
112.    if(q>MAX_SIZE) // 非零元素個數太多
113.      return ERROR;
114.    return OK;
115.  }
117.  Status SubtSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q)
118.  { // 求稀疏矩陣的差Q=M-N
119.    int i;
120.    for(i=1;i<=N.tu;i++)
121.      N.data[i].e*=-1;
122.    return AddSMatrix(M,N,Q);
123.  }
125.  void TransposeSMatrix(TSMatrix M,TSMatrix &T)
126.  { // 求稀疏矩陣M的轉置矩陣T。算法5.1改
127.    int p,q,col;
128.    T.mu=M.nu;
129.    T.nu=M.mu;
130.    T.tu=M.tu;
131.    if(T.tu)
132.    {
133.      q=1;
134.      for(col=1;col<=M.nu;++col)
135.        for(p=1;p<=M.tu;++p)
136.          if(M.data[p].j==col)
137.          {
138.            T.data[q].i=M.data[p].j;
139.            T.data[q].j=M.data[p].i;
140.            T.data[q].e=M.data[p].e;
141.            ++q;
142.          }
143.    }
144.  }
146.  Status MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q)
147.  { // 求稀疏矩陣的乘積Q=M×N
148.    int i,j;
149.    ElemType *Nc,*Tc;
150.    TSMatrix T; // 臨時矩陣
151.    if(M.nu!=N.mu)
152.      return ERROR;
153.    T.nu=M.mu; // 臨時矩陣T是Q的轉秩矩陣
154.    T.mu=N.nu;
155.    T.tu=0;
156.    Nc=(ElemType*)malloc((N.mu+1)*sizeof(ElemType)); // Nc爲矩陣N一列的臨時數組(非壓縮,[0]不用)
157.    Tc=(ElemType*)malloc((M.nu+1)*sizeof(ElemType)); // Tc爲矩陣T一行的臨時數組(非壓縮,[0]不用)
158.    if(!Nc||!Tc) // 創建臨時數組不成功
159.      exit(ERROR);
160.    for(i=1;i<=N.nu;i++) // 對於N的每一列
161.    {
162.      for(j=1;j<=N.mu;j++)
163.        Nc[j]=0; // 矩陣Nc的初值爲0
164.      for(j=1;j<=M.mu;j++)
165.        Tc[j]=0; // 臨時數組Tc的初值爲0，[0]不用
166.      for(j=1;j<=N.tu;j++) // 對於N的每一個非零元素
167.        if(N.data[j].j==i) // 屬於第i列
168.      Nc[N.data[j].i]=N.data[j].e; // 根據其所在行將其元素值賦給相應的Nc
169.      for(j=1;j<=M.tu;j++) // 對於M的每一個值
170.        Tc[M.data[j].i]+=M.data[j].e*Nc[M.data[j].j]; // Tc中存N的第i列與M相乘的結果
171.      for(j=1;j<=M.mu;j++)
172.        if(Tc[j]!=0)
173.        {
174.          T.data[++T.tu].e=Tc[j];
175.          T.data[T.tu].i=i;
176.          T.data[T.tu].j=j;
177.        }
178.    }
179.    if(T.tu>MAX_SIZE) // 非零元素個數太多
180.      return ERROR;
181.    TransposeSMatrix(T,Q); // 將T的轉秩賦給Q
182.    DestroySMatrix(T); // 銷燬臨時矩陣T
183.    free(Tc); // 釋放動態數組Tc和Nc
184.    free(Nc);
185.    return OK;
186.  }

1.  // bo5-3.cpp 行邏輯鏈接稀疏矩陣(存儲結構由c5-3.h定義)的基本操作(8個),包括算法5.3
2.  Status CreateSMatrix(RLSMatrix &M)
3.  { // 創建稀疏矩陣M
4.    int i,j;
5.    Triple T;
6.    Status k;
7.    printf("請輸入矩陣的行數,列數,非零元素數：");
8.    scanf("%d,%d,%d",&M.mu,&M.nu,&M.tu);
9.    if(M.tu>MAX_SIZE||M.mu>MAX_RC)
10.      return ERROR;
11.    M.data[0].i=0; // 爲以下比較做準備
12.    for(i=1;i<=M.tu;i++)
13.    {
14.      do
15.      {
16.        printf("請按行序順序輸入第%d個非零元素所在的行(1～%d),列(1～%d),元素值:",i,M.mu,M.nu);
17.        scanf("%d,%d,%d",&T.i,&T.j,&T.e);
18.        k=0;
19.        if(T.i<1||T.i>M.mu||T.j<1||T.j>M.nu) // 行、列超出範圍
20.          k=1;
21.        if(T.i<M.data[i-1].i||T.i==M.data[i-1].i&&T.j<=M.data[i-1].j) // 沒有按順序輸入非零元素
22.          k=1;
23.      }while(k); // 當輸入有誤，重新輸入
24.      M.data[i]=T;
25.    }
26.    for(i=1;i<=M.mu;i++) // 給rpos[]賦初值0
27.      M.rpos[i]=0;
28.    for(i=1;i<=M.tu;i++) // 計算每行非零元素數並賦給rpos[]
29.      M.rpos[M.data[i].i]++;
30.    for(i=M.mu;i>=1;i--) // 計算rpos[]
31.    {
32.      M.rpos[i]=1; // 賦初值1
33.      for(j=i-1;j>=1;j--)
34.        M.rpos[i]+=M.rpos[j];
35.    }
36.    return OK;
37.  }
39.  void DestroySMatrix(RLSMatrix &M)
40.  { // 銷燬稀疏矩陣M(使M爲0行0列0個非零元素的矩陣)
41.    M.mu=M.nu=M.tu=0;
42.  }
44.  void PrintSMatrix(RLSMatrix M)
45.  { // 輸出稀疏矩陣M
46.    int i;
47.    printf("%d行%d列%d個非零元素。/n",M.mu,M.nu,M.tu);
48.    printf("行  列  元素值/n");
49.    for(i=1;i<=M.tu;i++)
50.      printf("%2d%4d%8d/n",M.data[i].i,M.data[i].j,M.data[i].e);
51.    for(i=1;i<=M.mu;i++)
52.      printf("第%d行的第一個非零元素是本矩陣第%d個元素/n",i,M.rpos[i]);
53.  }
55.  void PrintSMatrix1(RLSMatrix M)
56.  { // 按矩陣形式輸出M
57.    int i,j,k=1;
58.    Triple *p=M.data;
59.    p++; // p指向第1個非零元素
60.    for(i=1;i<=M.mu;i++)
61.    {
62.      for(j=1;j<=M.nu;j++)
63.        if(k<=M.tu&&p->i==i&&p->j==j) // p指向非零元，且p所指元素爲當前處理元素
64.        {
65.          printf("%3d",p->e); // 輸出p所指元素的值
66.          p++; // p指向下一個元素
67.          k++; // 計數器+1
68.        }
69.        else // p所指元素不是當前處理元素
70.          printf("%3d",0); // 輸出0
71.      printf("/n");
72.    }
73.  }
75.  void CopySMatrix(RLSMatrix M,RLSMatrix &T)
76.  { // 由稀疏矩陣M複製得到T
77.    T=M;
78.  }
80.  Status AddSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix &Q)
81.  { // 求稀疏矩陣的和Q=M+N
82.    int k,p,q,tm,tn;
83.    if(M.mu!=N.mu||M.nu!=N.nu)
84.      return ERROR;
85.    Q.mu=M.mu; // Q矩陣行數
86.    Q.nu=M.nu; // Q矩陣列數
87.    Q.tu=0; // Q矩陣非零元素數初值
88.    for(k=1;k<=M.mu;++k) // 對於每一行，k指示行號
89.    {
90.      Q.rpos[k]=Q.tu+1; // Q矩陣第k行的第1個元素的位置
91.      p=M.rpos[k]; // p指示M矩陣第k行當前元素的序號
92.      q=N.rpos[k]; // q指示N矩陣第k行當前元素的序號
93.      if(k==M.mu) // 是最後一行
94.      {
95.        tm=M.tu+1; // tm，tn分別是p，q的上界
96.        tn=N.tu+1;
97.      }
98.      else
99.      {
100.        tm=M.rpos[k+1];
101.        tn=N.rpos[k+1];
102.      }
103.      while(p<tm&&q<tn) // M，N矩陣均有第k行元素未處理
104.        if(M.data[p].j==N.data[q].j) // M矩陣當前元素的列=N矩陣當前元素的列
105.        {
106.      if(M.data[p].e+N.data[q].e!=0) // 和不爲0，存入Q
107.      {
108.        Q.data[++Q.tu]=M.data[p];
109.        Q.data[Q.tu].e+=N.data[q].e;
110.      }
111.      p++;
112.      q++;
113.        }
114.        else if(M.data[p].j<N.data[q].j) // M矩陣當前元素的列<N矩陣當前元素的列
115.      Q.data[++Q.tu]=M.data[p++]; // 將M的當前值賦給Q
116.        else // M矩陣當前元素的列>N矩陣當前元素的列
117.          Q.data[++Q.tu]=N.data[q++]; // 將N的當前值賦給Q
118.      while(p<tm) // M矩陣還有第k行的元素未處理
119.        Q.data[++Q.tu]=M.data[p++]; // 將M的當前值賦給Q
120.      while(q<tn) // N矩陣還有k行的元素未處理
121.        Q.data[++Q.tu]=N.data[q++]; // 將N的當前值賦給Q
122.    }
123.    if(Q.tu>MAX_SIZE)
124.      return ERROR;
125.    else
126.      return OK;
127.  }
129.  Status SubtSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix &Q)
130.  { // 求稀疏矩陣的差Q=M-N
131.    int i;
132.    if(M.mu!=N.mu||M.nu!=N.nu)
133.      return ERROR;
134.    for(i=1;i<=N.tu;++i) // 對於N的每一元素，其值乘以-1
135.      N.data[i].e*=-1;
136.    AddSMatrix(M,N,Q); // Q=M+(-N)
137.    return OK;
138.  }
140.  Status MultSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix &Q)
141.  { // 求稀疏矩陣乘積Q=M×N。算法5.3改
142.    int arow,brow,p,q,ccol,ctemp[MAX_RC+1],t,tp;
143.    if(M.nu!=N.mu) // 矩陣M的列數應和矩陣N的行數相等
144.      return ERROR;
145.    Q.mu=M.mu; // Q初始化
146.    Q.nu=N.nu;
147.    Q.tu=0;
148.    if(M.tu*N.tu==0) // M和N至少有一個是零矩陣
149.      return ERROR;
150.    for(arow=1;arow<=M.mu;++arow)
151.    { // 從M的第一行開始，到最後一行，arow是M的當前行
152.      for(ccol=1;ccol<=Q.nu;++ccol)
153.        ctemp[ccol]=0; // Q的當前行的各列元素累加器清零
154.      Q.rpos[arow]=Q.tu+1; // Q當前行的第1個元素位於上1行最後1個元素之後
155.      if(arow<M.mu)
156.        tp=M.rpos[arow+1];
157.      else
158.        tp=M.tu+1; // 給最後1行設界
159.      for(p=M.rpos[arow];p<tp;++p)
160.      { // 對M當前行中每一個非零元
161.        brow=M.data[p].j; // 找到對應元在N中的行號(M當前元的列號)
162.        if(brow<N.mu)
163.          t=N.rpos[brow+1];
164.        else
165.          t=N.tu+1; // 給最後1行設界
166.        for(q=N.rpos[brow];q<t;++q)
167.        {
168.          ccol=N.data[q].j; // 乘積元素在Q中列號
169.          ctemp[ccol]+=M.data[p].e*N.data[q].e;
170.        }
171.      } // 求得Q中第arow行的非零元
172.      for(ccol=1;ccol<=Q.nu;++ccol) // 壓縮存儲該行非零元
173.        if(ctemp[ccol]!=0)
174.        {
175.          if(++Q.tu>MAX_SIZE)
176.            return ERROR;
177.          Q.data[Q.tu].i=arow;
178.          Q.data[Q.tu].j=ccol;
179.          Q.data[Q.tu].e=ctemp[ccol];
180.        }
181.    }
182.    return OK;
183.  }
185.  void TransposeSMatrix(RLSMatrix M,RLSMatrix &T)
186.  { // 求稀疏矩陣M的轉置矩陣T
187.    int p,q,t,col,*num;
188.    num=(int *)malloc((M.nu+1)*sizeof(int));
189.    T.mu=M.nu;
190.    T.nu=M.mu;
191.    T.tu=M.tu;
192.    if(T.tu)
193.    {
194.      for(col=1;col<=M.nu;++col)
195.        num[col]=0;  // 設初值
196.      for(t=1;t<=M.tu;++t) // 求M中每一列非零元個數
197.        ++num[M.data[t].j];
198.      T.rpos[1]=1;
199.      for(col=2;col<=M.nu;++col) // 求M中第col中第一個非零元在T.data中的序號
200.        T.rpos[col]=T.rpos[col-1]+num[col-1];
201.      for(col=1;col<=M.nu;++col)
202.        num[col]=T.rpos[col];
203.      for(p=1;p<=M.tu;++p)
204.      {
205.        col=M.data[p].j;
206.        q=num[col];
207.        T.data[q].i=M.data[p].j;
208.        T.data[q].j=M.data[p].i;
209.        T.data[q].e=M.data[p].e;
210.        ++num[col];
211.      }
212.    }
213.    free(num);
214.  }

1.  // bo5-4.cpp 稀疏矩陣的十字鏈表存儲(存儲結構由c5-4.h定義)的基本操作(9個)，包括算法5.4
3.  void InitSMatrix(CrossList &M)
4.  { // 初始化M(CrossList類型的變量必須初始化，否則創建、複製矩陣將出錯)。加
5.    M.rhead=M.chead=NULL;
6.    M.mu=M.nu=M.tu=0;
7.  }
9.  void InitSMatrixList(CrossList &M)
10.  { // 初始化十字鏈表表頭指針向量。加
11.    int i;
12.    if(!(M.rhead=(OLink*)malloc((M.mu+1)*sizeof(OLink)))) // 生成行表頭指針向量
13.      exit(OVERFLOW);
14.    if(!(M.chead=(OLink*)malloc((M.nu+1)*sizeof(OLink)))) // 生成列表頭指針向量
15.      exit(OVERFLOW);
16.    for(i=1;i<=M.mu;i++) // 初始化矩陣T的行表頭指針向量，各行鏈表爲空
17.      M.rhead[i]=NULL;
18.    for(i=1;i<=M.nu;i++) // 初始化矩陣T的列表頭指針向量，各列鏈表爲空
19.      M.chead[i]=NULL;
20.  }
22.  void InsertAscend(CrossList &M,OLink p)
23.  { // 初始條件：稀疏矩陣M存在,p指向的結點存在。操作結果：按行列升序將p所指結點插入M
24.    OLink q=M.rhead[p->i]; // q指向待插行表
25.    if(!q||p->j<q->j) // 待插的行表空或p所指結點的列值小於首結點的列值
26.    {
27.      p->right=M.rhead[p->i]; // 插在表頭
28.      M.rhead[p->i]=p;
29.    }
30.    else
31.    {
32.      while(q->right&&q->right->j<p->j) // q所指不是尾結點且q的下一結點的列值小於p所指結點的列值
33.        q=q->right; // q向後移
34.      p->right=q->right; // 將p插在q所指結點之後
35.      q->right=p;
36.    }
37.    q=M.chead[p->j]; // q指向待插列表
38.    if(!q||p->i<q->i) // 待插的列表空或p所指結點的行值小於首結點的行值
39.    {
40.      p->down=M.chead[p->j]; // 插在表頭
41.      M.chead[p->j]=p;
42.    }
43.    else
44.    {
45.      while(q->down&&q->down->i<p->i) // q所指不是尾結點且q的下一結點的行值小於p所指結點的行值
46.        q=q->down; // q向下移
47.      p->down=q->down; // 將p插在q所指結點之下
48.      q->down=p;
49.    }
50.    M.tu++;
51.  }
53.  void DestroySMatrix(CrossList &M)
54.  { // 初始條件：稀疏矩陣M存在。操作結果：銷燬稀疏矩陣M
55.    int i;
56.    OLink p,q;
57.    for(i=1;i<=M.mu;i++) // 按行釋放結點
58.    {
59.      p=*(M.rhead+i);
60.      while(p)
61.      {
62.        q=p;
63.        p=p->right;
64.        free(q);
65.      }
66.    }
67.    free(M.rhead);
68.    free(M.chead);
69.    InitSMatrix(M);
70.  }
72.  void CreateSMatrix(CrossList &M)
73.  { // 創建稀疏矩陣M，採用十字鏈表存儲表示。算法5.4改
74.    int i,k;
75.    OLink p;
76.    if(M.rhead)
77.      DestroySMatrix(M);
78.    printf("請輸入稀疏矩陣的行數 列數 非零元個數: ");
79.    scanf("%d%d%d",&M.mu,&M.nu,&i);
80.    InitSMatrixList(M); // 初始化M的表頭指針向量
81.    printf("請按任意次序輸入%d個非零元的行 列 元素值:/n",M.tu);
82.    for(k=0;k<i;k++)
83.    {
84.      p=(OLink)malloc(sizeof(OLNode)); // 生成結點
85.      if(!p)
86.        exit(OVERFLOW);
87.      scanf("%d%d%d",&p->i,&p->j,&p->e); // 給結點的3個成員賦值
88.      InsertAscend(M,p); // 將結點p按行列值升序插到矩陣M中
89.    }
90.  }
92.  void PrintSMatrix(CrossList M)
93.  { // 初始條件：稀疏矩陣M存在。操作結果：按行或按列輸出稀疏矩陣M
94.    int i,j;
95.    OLink p;
96.    printf("%d行%d列%d個非零元素/n",M.mu,M.nu,M.tu);
97.    printf("請輸入選擇(1.按行輸出 2.按列輸出): ");
98.    scanf("%d",&i);
99.    switch(i)
100.    {
101.      case 1: for(j=1;j<=M.mu;j++)
102.              {
103.                p=M.rhead[j];
104.                while(p)
105.                {
106.                  cout<<p->i<<"行"<<p->j<<"列值爲"<<p->e<<endl;
107.                  p=p->right;
108.                }
109.              }
110.              break;
111.      case 2: for(j=1;j<=M.nu;j++)
112.          {
113.            p=M.chead[j];
114.                while(p)
115.                {
116.                  cout<<p->i<<"行"<<p->j<<"列值爲"<<p->e<<endl;
117.                  p=p->down;
118.                }
119.              }
120.    }
121.  }
123.  void PrintSMatrix1(CrossList M)
124.  { // 按矩陣形式輸出M
125.    int i,j;
126.    OLink p;
127.    for(i=1;i<=M.mu;i++)
128.    { // 從第1行到最後1行
129.      p=M.rhead[i]; // p指向該行的第1個非零元素
130.      for(j=1;j<=M.nu;j++) // 從第1列到最後1列
131.        if(!p||p->j!=j) // 已到該行表尾或當前結點的列值不等於當前列值
132.          printf("%-3d",0); // 輸出0
133.        else
134.        {
135.          printf("%-3d",p->e);
136.          p=p->right;
137.        }
138.      printf("/n");
139.    }
140.  }
142.  void CopySMatrix(CrossList M,CrossList &T)
143.  { // 初始條件：稀疏矩陣M存在。操作結果：由稀疏矩陣M複製得到T
144.    int i;
145.    OLink p,q;
146.    if(T.rhead) // 矩陣T存在
147.      DestroySMatrix(T);
148.    T.mu=M.mu;
149.    T.nu=M.nu;
150.    InitSMatrixList(T); // 初始化T的表頭指針向量
151.    for(i=1;i<=M.mu;i++) // 按行復制
152.    {
153.      p=M.rhead[i]; // p指向i行鏈表頭
154.      while(p) // 沒到行尾
155.      {
156.        if(!(q=(OLNode*)malloc(sizeof(OLNode)))) // 生成結點q
157.          exit(OVERFLOW);
158.        *q=*p; // 給結點q賦值
159.        InsertAscend(T,q); // 將結點q按行列值升序插到矩陣T中
160.        p=p->right;
161.      }
162.    }
163.  }
165.  int comp(int c1,int c2)
166.  { // AddSMatrix函數要用到，另加
167.    if(c1<c2)
168.      return -1;
169.    if(c1==c2)
170.      return 0;
171.    return 1;
172.  }
174.  void AddSMatrix(CrossList M,CrossList N,CrossList &Q)
175.  { // 初始條件：稀疏矩陣M與N的行數和列數對應相等。操作結果：求稀疏矩陣的和Q=M+N
176.    int i;
177.    OLink pq,pm,pn;
178.    if(M.mu!=N.mu||M.nu!=N.nu)
179.    {
180.      printf("兩個矩陣不是同類型的,不能相加/n");
181.      exit(OVERFLOW);
182.    }
183.    Q.mu=M.mu; // 初始化Q矩陣
184.    Q.nu=M.nu;
185.    Q.tu=0; // Q矩陣元素個數的初值爲0
186.    InitSMatrixList(Q); // 初始化Q的表頭指針向量
187.    for(i=1;i<=M.mu;i++) // 按行的順序相加
188.    {
189.      pm=M.rhead[i]; // pm指向矩陣M的第i行的第1個結點
190.      pn=N.rhead[i]; // pn指向矩陣N的第i行的第1個結點
191.      while(pm&&pn) // pm和pn均不空
192.      {
193.        pq=(OLink)malloc(sizeof(OLNode)); // 生成矩陣Q的結點
194.        switch(comp(pm->j,pn->j))
195.        {
196.      case -1: *pq=*pm; // M的列<N的列，將矩陣M的當前元素值賦給pq
197.           InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
198.           pm=pm->right; // 指針向後移
199.           break;
200.      case  0: *pq=*pm; // M、N矩陣的列相等，元素值相加
201.           pq->e+=pn->e;
202.                   if(pq->e!=0) // 和爲非零元素
203.                     InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
204.                   else
205.                     free(pq); // 釋放結點
206.                   pm=pm->right; // 指針向後移
207.                   pn=pn->right;
208.                   break;
209.          case  1: *pq=*pn; // M的列>N的列，將矩陣N的當前元素值賦給pq
210.                   InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
211.                   pn=pn->right; // 指針向後移
212.        }
213.      }
214.      while(pm) // pn=NULL
215.      {
216.        pq=(OLink)malloc(sizeof(OLNode)); // 生成矩陣Q的結點
217.        *pq=*pm; // M的列<N的列，將矩陣M的當前元素值賦給pq
218.        InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
219.        pm=pm->right; // 指針向後移
220.      }
221.      while(pn) // pm=NULL
222.      {
223.        pq=(OLink)malloc(sizeof(OLNode)); // 生成矩陣Q的結點
224.        *pq=*pn; // M的列>N的列，將矩陣N的當前元素值賦給pq
225.        InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
226.        pn=pn->right; // 指針向後移
227.      }
228.    }
229.    if(Q.tu==0) // Q矩陣元素個數爲0
230.      DestroySMatrix(Q); // 銷燬矩陣Q
231.  }
233.  void SubtSMatrix(CrossList M,CrossList N,CrossList &Q)
234.  { // 初始條件：稀疏矩陣M與N的行數和列數對應相等。操作結果：求稀疏矩陣的差Q=M-N
235.    int i;
236.    OLink pq,pm,pn;
237.    if(M.mu!=N.mu||M.nu!=N.nu)
238.    {
239.      printf("兩個矩陣不是同類型的,不能相減/n");
240.      exit(OVERFLOW);
241.    }
242.    Q.mu=M.mu; // 初始化Q矩陣
243.    Q.nu=M.nu;
244.    Q.tu=0; // Q矩陣元素個數的初值爲0
245.    InitSMatrixList(Q); // 初始化Q的表頭指針向量
246.    for(i=1;i<=M.mu;i++) // 按行的順序相減
247.    {
248.      pm=M.rhead[i]; // pm指向矩陣M的第i行的第1個結點
249.      pn=N.rhead[i]; // pn指向矩陣N的第i行的第1個結點
250.      while(pm&&pn) // pm和pn均不空
251.      {
252.        pq=(OLink)malloc(sizeof(OLNode)); // 生成矩陣Q的結點
253.        switch(comp(pm->j,pn->j))
254.        {
255.      case -1: *pq=*pm; // M的列<N的列，將矩陣M的當前元素值賦給pq
256.           InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
257.           pm=pm->right; // 指針向後移
258.           break;
259.      case  0: *pq=*pm; // M、N矩陣的列相等，元素值相減
260.                   pq->e-=pn->e;
261.                   if(pq->e!=0) // 差爲非零元素
262.                     InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
263.                   else
264.                     free(pq); // 釋放結點
265.                   pm=pm->right; // 指針向後移
266.                   pn=pn->right;
267.                   break;
268.          case  1: *pq=*pn; // M的列>N的列，將矩陣N的當前元素值賦給pq
269.                   pq->e*=-1; // 求反
270.                   InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
271.                   pn=pn->right; // 指針向後移
272.        }
273.      }
274.      while(pm) // pn=NULL
275.      {
276.        pq=(OLink)malloc(sizeof(OLNode)); // 生成矩陣Q的結點
277.        *pq=*pm; // M的列<N的列，將矩陣M的當前元素值賦給pq
278.        InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
279.        pm=pm->right; // 指針向後移
280.      }
281.      while(pn) // pm=NULL
282.      {
283.        pq=(OLink)malloc(sizeof(OLNode)); // 生成矩陣Q的結點
284.        *pq=*pn; // M的列>N的列，將矩陣N的當前元素值賦給pq
285.        pq->e*=-1; // 求反
286.        InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
287.        pn=pn->right; // 指針向後移
288.      }
289.    }
290.    if(Q.tu==0) // Q矩陣元素個數爲0
291.      DestroySMatrix(Q); // 銷燬矩陣Q
292.  }
294.  void MultSMatrix(CrossList M,CrossList N,CrossList &Q)
295.  { // 初始條件：稀疏矩陣M的列數等於N的行數。操作結果：求稀疏矩陣乘積Q=M×N
296.    int i,j,e;
297.    OLink pq,pm,pn;
298.    InitSMatrix(Q);
299.    Q.mu=M.mu;
300.    Q.nu=N.nu;
301.    Q.tu=0;
302.    InitSMatrixList(Q); // 初始化Q的表頭指針向量
303.    for(i=1;i<=Q.mu;i++)
304.      for(j=1;j<=Q.nu;j++)
305.      {
306.        pm=M.rhead[i];
307.        pn=N.chead[j];
308.        e=0;
309.        while(pm&&pn)
310.          switch(comp(pn->i,pm->j))
311.          {
312.            case -1: pn=pn->down; // 列指針後移
313.                     break;
314.            case  0: e+=pm->e*pn->e; // 乘積累加
315.             pn=pn->down; // 行列指針均後移
316.                     pm=pm->right;
317.                     break;
318.            case  1: pm=pm->right; // 行指針後移
319.          }
320.        if(e) // 值不爲0
321.        {
322.          pq=(OLink)malloc(sizeof(OLNode)); // 生成結點
323.          if(!pq) // 生成結點失敗
324.            exit(OVERFLOW);
325.          pq->i=i; // 給結點賦值
326.          pq->j=j;
327.          pq->e=e;
328.          InsertAscend(Q,pq); // 將結點pq按行列值升序插到矩陣Q中
329.        }
330.      }
331.    if(Q.tu==0) // Q矩陣元素個數爲0
332.      DestroySMatrix(Q); // 銷燬矩陣Q
333.  }
335.  void TransposeSMatrix(CrossList M,CrossList &T)
336.  { // 初始條件：稀疏矩陣M存在。操作結果：求稀疏矩陣M的轉置矩陣T
337.    int u,i;
338.    OLink *head,p,q,r;
339.    CopySMatrix(M,T); // T=M
340.    u=T.mu; // 交換T.mu和T.nu
341.    T.mu=T.nu;
342.    T.nu=u;
343.    head=T.rhead; // 交換T.rhead和T.chead
344.    T.rhead=T.chead;
345.    T.chead=head;
346.    for(u=1;u<=T.mu;u++) // 對T的每一行
347.    {
348.      p=T.rhead[u]; // p爲行表頭
349.      while(p) // 沒到表尾，對T的每一結點
350.      {
351.        q=p->down; // q指向下一個結點
352.        i=p->i; // 交換.i和.j
353.        p->i=p->j;
354.        p->j=i;
355.        r=p->down; // 交換.down和.right
356.        p->down=p->right;
357.        p->right=r;
358.        p=q; // p指向下一個結點
359.      }
360.    }
361.  }

1.  // bo5-5.cpp 廣義表的頭尾鏈表存儲(存儲結構由c5-5.h定義)的基本操作(11個),包括算法5.5,5.6,5.7
2.  #include"func5-1.cpp" // 算法5.8
3.  void InitGList(GList &L)
4.  { // 創建空的廣義表L
5.    L=NULL;
6.  }
8.  void CreateGList(GList &L,SString S) // 算法5.7
9.  { // 採用頭尾鏈表存儲結構，由廣義表的書寫形式串S創建廣義表L。設emp="()"
10.    SString sub,hsub,emp;
11.    GList p,q;
12.    StrAssign(emp,"()"); // 空串emp="()"
13.    if(!StrCompare(S,emp)) // S="()"
14.      L=NULL; // 創建空表
15.    else // S不是空串
16.    {
17.      if(!(L=(GList)malloc(sizeof(GLNode)))) // 建表結點
18.        exit(OVERFLOW);
19.      if(StrLength(S)==1) // S爲單原子，只會出現在遞歸調用中
20.      {
21.        L->tag=ATOM;
22.        L->atom=S[1]; // 創建單原子廣義表
23.      }
24.      else // S爲表
25.      {
26.        L->tag=LIST;
27.        p=L;
28.        SubString(sub,S,2,StrLength(S)-2); // 脫外層括號(去掉第1個字符和最後1個字符)給串sub
29.        do
30.        { // 重複建n個子表
31.          sever(sub,hsub); // 從sub中分離出表頭串hsub
32.          CreateGList(p->ptr.hp,hsub);
33.          q=p;
34.          if(!StrEmpty(sub)) // 表尾不空
35.          {
36.            if(!(p=(GLNode *)malloc(sizeof(GLNode))))
37.              exit(OVERFLOW);
38.            p->tag=LIST;
39.        q->ptr.tp=p;
40.          }
41.        }while(!StrEmpty(sub));
42.        q->ptr.tp=NULL;
43.      }
44.    }
45.  }
47.  void DestroyGList(GList &L)
48.  { // 銷燬廣義表L
49.    GList q1,q2;
50.    if(L)
51.    {
52.      if(L->tag==LIST) // 刪除表結點
53.      {
54.        q1=L->ptr.hp; // q1指向表頭
55.        q2=L->ptr.tp; // q2指向表尾
56.        DestroyGList(q1); // 銷燬表頭
57.        DestroyGList(q2); // 銷燬表尾
58.      }
59.      free(L);
60.      L=NULL;
61.    }
62.  }
64.  void CopyGList(GList &T,GList L)
65.  { // 採用頭尾鏈表存儲結構，由廣義表L複製得到廣義表T。算法5.6
66.    if(!L) // 複製空表
67.      T=NULL;
68.    else
69.    {
70.      T=(GList)malloc(sizeof(GLNode)); // 建表結點
71.      if(!T)
72.        exit(OVERFLOW);
73.      T->tag=L->tag;
74.      if(L->tag==ATOM)
75.        T->atom=L->atom; // 複製單原子
76.      else
77.      {
78.        CopyGList(T->ptr.hp,L->ptr.hp); // 遞歸複製子表
79.        CopyGList(T->ptr.tp,L->ptr.tp);
80.      }
81.    }
82.  }
84.  int GListLength(GList L)
85.  { // 返回廣義表的長度，即元素個數
86.    int len=0;
87.    while(L)
88.    {
89.      L=L->ptr.tp;
90.      len++;
91.    }
92.    return len;
93.  }
95.  int GListDepth(GList L)
96.  { // 採用頭尾鏈表存儲結構，求廣義表L的深度。算法5.5
97.    int max,dep;
98.    GList pp;
99.    if(!L)
100.      return 1; // 空表深度爲1
101.    if(L->tag==ATOM)
102.      return 0; // 原子深度爲0，只會出現在遞歸調用中
103.    for(max=0,pp=L;pp;pp=pp->ptr.tp)
104.    {
105.      dep=GListDepth(pp->ptr.hp); // 遞歸求以pp->ptr.hp爲頭指針的子表深度
106.      if(dep>max)
107.        max=dep;
108.    }
109.    return max+1; // 非空表的深度是各元素的深度的最大值加1
110.  }
112.  Status GListEmpty(GList L)
113.  { // 判定廣義表是否爲空
114.    if(!L)
115.      return TRUE;
116.    else
117.      return FALSE;
118.  }
120.  GList GetHead(GList L)
121.  { // 生成廣義表L的表頭元素，返回指向這個元素的指針
122.    GList h,p;
123.    if(!L) // 空表無表頭
124.      return NULL;
125.    p=L->ptr.hp; // p指向L的表頭元素
126.    CopyGList(h,p); // 將表頭元素複製給h
127.    return h;
128.  }
130.  GList GetTail(GList L)
131.  { // 將廣義表L的表尾生成爲廣義表，返回指向這個新廣義表的指針
132.    GList t;
133.    if(!L) // 空表無表尾
134.      return NULL;
135.    CopyGList(t,L->ptr.tp); // 將L的表尾拷給t
136.    return t;
137.  }
139.  void InsertFirst_GL(GList &L,GList e)
140.  { // 初始條件：廣義表存在。操作結果：插入元素e(也可能是子表)作爲廣義表L的第1元素(表頭)
141.    GList p=(GList)malloc(sizeof(GLNode)); // 生成新結點
142.    if(!p)
143.      exit(OVERFLOW);
144.    p->tag=LIST; // 結點的類型是表
145.    p->ptr.hp=e; // 表頭指向e
146.    p->ptr.tp=L; // 表尾指向原表L
147.    L=p; // L指向新結點
148.  }
150.  void DeleteFirst_GL(GList &L,GList &e)
151.  { // 初始條件：廣義表L存在。操作結果：刪除廣義表L的第一元素，並用e返回其值
152.    GList p=L; // p指向第1個結點
153.    e=L->ptr.hp; // e指向L的表頭
154.    L=L->ptr.tp; // L指向原L的表尾
155.    free(p); // 釋放第1個結點
156.  }
158.  void Traverse_GL(GList L,void(*v)(AtomType))
159.  { // 利用遞歸算法遍歷廣義表L
160.    if(L) // L不空
161.      if(L->tag==ATOM) // L爲單原子
162.        v(L->atom);
163.      else // L爲廣義表
164.      {
165.        Traverse_GL(L->ptr.hp,v); // 遞歸遍歷L的表頭
166.        Traverse_GL(L->ptr.tp,v); // 遞歸遍歷L的表尾
167.      }
168.  }

1.  // bo5-6.cpp 廣義表的擴展線性鏈表存儲(存儲結構由c5-6.h定義)的基本操作(13個)
2.  #include"func5-1.cpp" // 算法5.8
4.  void InitGList(GList1 &L)
5.  { // 創建空的廣義表L
6.    L=NULL;
7.  }
9.  void CreateGList(GList1 &L,SString S) // 算法5.7改
10.  { // 採用擴展線性鏈表存儲結構，由廣義表的書寫形式串S創建廣義表L。設emp="()"
11.    SString emp,sub,hsub;
12.    GList1 p;
13.    StrAssign(emp,"()"); // 設emp="()"
14.    if(!(L=(GList1)malloc(sizeof(GLNode1)))) // 建表結點不成功
15.      exit(OVERFLOW);
16.    if(!StrCompare(S,emp)) // 創建空表
17.    {
18.      L->tag=LIST;
19.      L->hp=L->tp=NULL;
20.    }
21.    else if(StrLength(S)==1) // 創建單原子廣義表
22.    {
23.      L->tag=ATOM;
24.      L->atom=S[1];
25.      L->tp=NULL;
26.    }
27.    else // 創建一般表
28.    {
29.      L->tag=LIST;
30.      L->tp=NULL;
31.      SubString(sub,S,2,StrLength(S)-2); // 脫外層括號(去掉第1個字符和最後1個字符)給串sub
32.      sever(sub,hsub); // 從sub中分離出表頭串hsub
33.      CreateGList(L->hp,hsub);
34.      p=L->hp;
35.      while(!StrEmpty(sub)) // 表尾不空，則重複建n個子表
36.      {
37.        sever(sub,hsub); // 從sub中分離出表頭串hsub
38.        CreateGList(p->tp,hsub);
39.        p=p->tp;
40.      };
41.    }
42.  }
44.  void DestroyGList(GList1 &L)
45.  { // 初始條件：廣義表L存在。操作結果：銷燬廣義表L
46.    GList1 ph,pt;
47.    if(L) // L不爲空表
48.    { // 由ph和pt接替L的兩個指針
49.      if(L->tag) // 是子表
50.        ph=L->hp;
51.      else // 是原子
52.        ph=NULL;
53.      pt=L->tp;
54.      DestroyGList(ph); // 遞歸銷燬表ph
55.      DestroyGList(pt); // 遞歸銷燬表pt
56.      free(L); // 釋放L所指結點
57.      L=NULL; // 令L爲空
58.    }
59.  }
61.  void CopyGList(GList1 &T,GList1 L)
62.  { // 初始條件：廣義表L存在。操作結果：由廣義表L複製得到廣義表T
63.    T=NULL;
64.    if(L) // L不空
65.    {
66.      T=(GList1)malloc(sizeof(GLNode1));
67.      if(!T)
68.        exit(OVERFLOW);
69.      T->tag=L->tag; // 複製枚舉變量
70.      if(L->tag==ATOM) // 複製共用體部分
71.        T->atom=L->atom; // 複製單原子
72.      else
73.        CopyGList(T->hp,L->hp); // 複製子表
74.      if(L->tp==NULL) // 到表尾
75.        T->tp=L->tp;
76.      else
77.        CopyGList(T->tp,L->tp); // 複製子表
78.    }
79.  }
81.  int GListLength(GList1 L)
82.  { // 初始條件：廣義表L存在。操作結果：求廣義表L的長度，即元素個數
83.    int len=0;
84.    GList1 p=L->hp; // p指向第1個元素
85.    while(p)
86.    {
87.      len++;
88.      p=p->tp;
89.    };
90.    return len;
91.  }
93.  int GListDepth(GList1 L)
94.  { // 初始條件：廣義表L存在。操作結果：求廣義表L的深度
95.    int max,dep;
96.    GList1 pp;
97.    if(L==NULL||L->tag==LIST&&!L->hp)
98.      return 1; // 空表深度爲1
99.    else if(L->tag==ATOM)
100.      return 0; // 單原子表深度爲0，只會出現在遞歸調用中
101.    else // 求一般表的深度
102.      for(max=0,pp=L->hp;pp;pp=pp->tp)
103.      {
104.        dep=GListDepth(pp); // 求以pp爲頭指針的子表深度
105.        if(dep>max)
106.          max=dep;
107.      }
108.    return max+1; // 非空表的深度是各元素的深度的最大值加1
109.  }
111.  Status GListEmpty(GList1 L)
112.  { // 初始條件：廣義表L存在。操作結果：判定廣義表L是否爲空
113.    if(!L||L->tag==LIST&&!L->hp)
114.      return OK;
115.    else
116.      return ERROR;
117.  }
119.  GList1 GetHead(GList1 L)
120.  { // 生成廣義表L的表頭元素，返回指向這個元素的指針
121.    GList1 h,p;
122.    if(!L||L->tag==LIST&&!L->hp) // 空表無表頭
123.      return NULL;
124.    p=L->hp->tp; // p指向L的表尾
125.    L->hp->tp=NULL; // 截去L的表尾部分
126.    CopyGList(h,L->hp); // 將表頭元素複製給h
127.    L->hp->tp=p; // 恢復L的表尾(保持原L不變)
128.    return h;
129.  }
131.  GList1 GetTail(GList1 L)
132.  { // 將廣義表L的表尾生成爲廣義表，返回指向這個新廣義表的指針
133.    GList1 t,p;
134.    if(!L||L->tag==LIST&&!L->hp) // 空表無表尾
135.      return NULL;
136.    p=L->hp; // p指向表頭
137.    L->hp=p->tp; // 在L中刪去表頭
138.    CopyGList(t,L); // 將L的表尾拷給t
139.    L->hp=p; // 恢復L的表頭(保持原L不變)
140.    return t;
141.  }
143.  void InsertFirst_GL(GList1 &L,GList1 e)
144.  { // 初始條件：廣義表存在。操作結果：插入元素e(也可能是子表)作爲廣義表L的第1元素(表頭)
145.    GList1 p=L->hp;
146.    L->hp=e;
147.    e->tp=p;
148.  }
150.  void DeleteFirst_GL(GList1 &L,GList1 &e)
151.  { // 初始條件：廣義表L存在。操作結果：刪除廣義表L的第一元素，並用e返回其值
152.    if(L&&L->hp)
153.    {
154.      e=L->hp;
155.      L->hp=e->tp;
156.      e->tp=NULL;
157.    }
158.    else
159.      e=L;
160.  }
162.  void Traverse_GL(GList1 L,void(*v)(AtomType))
163.  { // 利用遞歸算法遍歷廣義表L
164.    GList1 hp;
165.    if(L) // L不空
166.    {
167.      if(L->tag==ATOM) // L爲單原子
168.      {
169.        v(L->atom);
170.        hp=NULL;
171.      }
172.      else // L爲子表
173.        hp=L->hp;
174.      Traverse_GL(hp,v);
175.      Traverse_GL(L->tp,v);
176.    }
177.  }