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.  }