严蔚敏版数据结构课后习题答案-完整版

简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。

解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

数据对象是性质相同的数据元素的集合，是数据的一个子集。 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

存储结构是数据结构在计算机中的表示。

数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。是对一般数据类型的扩展。

试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。

解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。抽象数据

类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。

设有数据结构(D,R)，其中

Dd1,d2,d3,d4，Rr，rd1,d2,d2,d3,d3,d4

试按图论中图的画法惯例画出其逻辑结构图。

解：

试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。 解： ADT Complex{

数据对象：D={r,i|r,i为实数} 数据关系：R={} 基本操作：

InitComplex(&C,re,im)

操作结果：构造一个复数C，其实部和虚部分别为re和im

DestroyCmoplex(&C)

操作结果：销毁复数C

Get(C,k,&e)

操作结果：用e返回复数C的第k元的值

Put(&C,k,e)

操作结果：改变复数C的第k元的值为e

IsAscending(C)

操作结果：如果复数C的两个元素按升序排列，则返回

1，否则返回0

IsDescending(C)

操作结果：如果复数C的两个元素按降序排列，则返回

1，否则返回0

Max(C,&e)

操作结果：用e返回复数C的两个元素中值较大的一个

Min(C,&e)

操作结果：用e返回复数C的两个元素中值较小的一个

}ADT Complex

ADT RationalNumber{

数据对象：D={s,m|s,m为自然数，且m不为0} 数据关系：R={} 基本操作：

InitRationalNumber(&R,s,m)

操作结果：构造一个有理数R，其分子和分母分别为s

和m

DestroyRationalNumber(&R)

操作结果：销毁有理数R

Get(R,k,&e)

操作结果：用e返回有理数R的第k元的值

Put(&R,k,e)

操作结果：改变有理数R的第k元的值为e

IsAscending(R)

操作结果：若有理数R的两个元素按升序排列，则返回

1，否则返回0

IsDescending(R)

操作结果：若有理数R的两个元素按降序排列，则返回

1，否则返回0 个 个

}ADT RationalNumber

Min(R,&e)

操作结果：用e返回有理数R的两个元素中值较小的一

Max(R,&e)

操作结果：用e返回有理数R的两个元素中值较大的一

试画出与下列程序段等价的框图。 (1) product=1; i=1;

while(i<=n){ product *= i; i++; } (2) i=0; do { i++;

} while((i!=n) && (a[i]!=x)); (3) switch {

case x在程序设计中，常用下列三种不同的出错处理方式： (1) 用exit语句终止执行并报告错误； (2) 以函数的返回值区别正确返回或错误返回；

(3) 设置一个整型变量的函数参数以区别正确返回或某种错误返回。

试讨论这三种方法各自的优缺点。

解：(1)exit常用于异常错误处理，它可以强行中断程序的执行，返回操作系统。

(2)以函数的返回值判断正确与否常用于子程序的测试，便于实

现程序的局部控制。

(3)用整型函数进行错误处理的优点是可以给出错误类型，便于迅速确定错误。

在程序设计中，可采用下列三种方法实现输出和输入： (1) 通过scanf和printf语句； (2) 通过函数的参数显式传递； (3) 通过全局变量隐式传递。 试讨论这三种方法的优缺点。

解：(1)用scanf和printf直接进行输入输出的好处是形象、直观，但缺点是需要对其进行格式控制，较为烦琐，如果出现错误，则会引起整个系统的崩溃。

(2)通过函数的参数传递进行输入输出，便于实现信息的隐蔽，减少出错的可能。

(3)通过全局变量的隐式传递进行输入输出最为方便，只需修改变量的值即可，但过多的全局变量使程序的维护较为困难。 设n为正整数。试确定下列各程序段中前置以记号@的语句的频度： (1) i=1; k=0; while(i<=n-1){ @ k += 10*i; i++; }

(2) i=1; k=0;

do {

@ k += 10*i; i++; } while(i<=n-1); (3) i=1; k=0; while (i<=n-1) { i++; @ k += 10*i; } (4) k=0;

for(i=1; i<=n; i++) { for(j=i; j<=n; j++) @ k++; }

(5) for(i=1; i<=n; i++) { for(j=1; j<=i; j++) { for(k=1; k<=j; k++) @ x += delta; }

(6) i=1; j=0; while(i+j<=n) { @ if(i>j) j++;

else i++; }

(7) x=n; y=0; .+1=

n(n1) 2n (5) 1+(1+2)+(1+2+3)+...+(1+2+3+...+n)=i1i(i1) 21n1n21n21n =i(i1)(ii)ii

2i12i12i12i1 =

111n(n1)(2n1)n(n1)n(n1)(2n3) 12412 (6) n

(7) n 向下取整 (8) 1100

假设n为2的乘幂，并且n>2，试求下列算法的时间复杂度及变量count的值（以n的函数形式表示）。 int Time(int n) {

count = 0; x=2; while(xreturn count;

}

解：o(log2n) count=log2n2

已知有实现同一功能的两个算法，其时间复杂度分别为O2n和

x *= 2; count++;

On10，假设现实计算机可连续运算的时间为107秒（100多天），又每

秒可执行基本操作（根据这些操作来估算算法时间复杂度）105次。试问在此条件下，这两个算法可解问题的规模（即n值的范围）各为多少哪个算法更适宜请说明理由。

解：2n1012

n=40

n=16

n101012

则对于同样的循环次数n，在这个规模下，第二种算法所花费的代价要大得多。故在这个规模下，第一种算法更适宜。 设有以下三个函数：

fn21n4n21000，gn15n4500n3，hn500n3.5nlogn 请判断以下断言正确与否： (1) f(n)是O(g(n)) (2) h(n)是O(f(n)) (3) g(n)是O(h(n)) (4) h(n)是O (5) h(n)是O(nlogn)

解：(1)对 (2)错 (3)错 (4)对 (5)错

试设定若干n值，比较两函数n2和50nlog2n的增长趋势，并确定n在什么范围内，函数n2的值大于50nlog2n的值。

解：n2的增长趋势快。但在n较小的时候，50nlog2n的值较大。

当n>438时，n250nlog2n

判断下列各对函数fn和gn，当n时，哪个函数增长更快

(1) fn10n2lnn!10n，gn2n4n7

3(2) fnlnn!52，gn13n2.5 (3) fnn2.1n41，gnlnn!2n

2(4) fn2n2n，gnnnn5

32解：(1)g(n)快 (2)g(n)快 (3)f(n)快 (4) f(n)快 试用数学归纳法证明： (1) i2nn12n1/6

i1nnn0

(2) xixn11/x1

i0nx1,n0

(3) 2i12n1

i1nn1 n1

(4) 2i1n2

i1 试写一算法，自大至小依次输出顺序读入的三个整数X，Y和Z的值

解：

int max3(int x,int y,int z) {

if(x>y)

if(x>z) return x; else return z;

else

if(y>z) return y; else return z;

}

已知k阶斐波那契序列的定义为

f00，f10，…，fk20，fk11； fnfn1fn2fnk，nk,k1,

试编写求k阶斐波那契序列的第m项值的函数算法，k和m均以值调用的形式在函数参数表中出现。

解：k>0为阶数，n为数列的第n项 int Fibonacci(int k,int n) {

if(k<1) exit(OVERFLOW); int *p,x;

p=new int[k+1]; if(!p) exit(OVERFLOW); int i,j;

for(i=0;i}

for(i=k+1;ix=p[0];

for(j=0;j}

}

return p[k];

假设有A，B，C，D，E五个高等院校进行田径对抗赛，各院校的单项成绩均已存入计算机，并构成一张表，表中每一行的形式为

项目名称 性别 校名 成绩 得分 编写算法，处理上述表格，以统计各院校的男、女总分和团体总分，并输出。

解：

typedef enum{A,B,C,D,E} SchoolName; typedef enum{Female,Male} SexType; typedef struct{ }

试编写算法，计算i!*2i的值并存入数组a[0..arrsize-1]的第i-1个分量中(i=1,2,…,n)。假设计算机中允许的整数最大值为maxint，

char event[3]; chool==sn){ } =+;

return temp;

}

if(a[i].sex==Male) +=a[i].score; if(a[i].sex==Female) +=a[i].score;

则当n>arrsize或对某个k1kn，使k!•2kmaxint时，应按出错处理。注意选择你认为较好的出错处理方法。

解： #include<> #include<>

#define MAXINT 65535 #define ArrSize 100 int fun(int i);

int main() { int i,k; int a[ArrSize]; cout<<\"Enter k:\"; cin>>k;

if(k>ArrSize-1) exit(0); for(i=0;i<=k;i++){ if(i==0) a[i]=1; else{ if(2*i*a[i-1]>MAXINT) exit(0); else a[i]=2*i*a[i-1];

}

}

}

for(i=0;i<=k;i++){ } return 0;

if(a[i]>MAXINT) exit(0); else cout<试编写算法求一元多项式的值Pnxaixi的值Pnx0，并确定算法

i0n中每一语句的执行次数和整个算法的时间复杂度。注意选择你认为较好的输入和输出方法。本题的输入为aii0,1,,n，x0和n，输出为

Pnx0。

解： #include<> #include<> #define N 10

double polynomail(int a[],int i,double x,int n); int main() {

double x;

int n,i; int a[N];

cout<<\"输入变量的值x:\";

cin>>x;

cout<<\"输入多项式的阶次n:\"; cin>>n;

if(n>N-1) exit(0);

cout<<\"输入多项式的系数a[0]--a[n]:\"; for(i=0;i<=n;i++) cin>>a[i]; cout<<\"The

polynomail

value

is

\"<double polynomail(int a[],int i,double x,int n) { }

本算法的时间复杂度为o(n)。 第2章 线性表

描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。

解：头指针是指向链表中第一个结点的指针。首元结点是指链表中存储第一个数据元素的结点。头结点是在首元结点之前附设的一个

if(i>0) return a[n-i]+polynomail(a,i-1,x,n)*x; else return a[n]; return 0;

结点，该结点不存储数据元素，其指针域指向首元结点，其作用主要是为了方便对链表的操作。它可以对空表、非空表以及首元结点的操作进行统一处理。 填空题。

解：(1) 在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与元素在表中的位置有关。

(2) 顺序表中逻辑上相邻的元素的物理位置必定紧邻。单链表中逻辑上相邻的元素的物理位置不一定紧邻。

(3) 在单链表中，除了首元结点外，任一结点的存储位置由其前驱结点的链域的值指示。

(4) 在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。

在什么情况下用顺序表比链表好

解：当线性表的数据元素在物理位置上是连续存储的时候，用顺序表比用链表好，其特点是可以进行随机存取。

对以下单链表分别执行下列各程序段，并画出结果示意图。

解：

画出执行下列各行语句后各指针及链表的示意图。

L=(LinkList)malloc(sizeof(LNode)); P=L; for(i=1;i<=4;i++){ }

P->next=NULL;

for(i=4;i>=1;i--) Ins_LinkList(L,i+1,i*2); for(i=1;i<=3;i++) Del_LinkList(L,i); 解：

已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。

a. 在P结点后插入S结点的语句序列是__________________。 b. 在P结点前插入S结点的语句序列是__________________。 c. 在表首插入S结点的语句序列是__________________。

P->next=(LinkList)malloc(sizeof(LNode)); P=P->next; P->data=i*2-1;

d. 在表尾插入S结点的语句序列是__________________。 (1) P->next=S;

(2) P->next=P->next->next; (3) P->next=S->next; (4) S->next=P->next; (5) S->next=L; (6) S->next=NULL; (7) Q=P;

(8) while(P->next!=Q) P=P->next; (9) while(P->next!=NULL) P=P->next; (10) P=Q; (11) P=L; (12) L=S; (13) L=P; 解：a. (4) (1)

b. (7) (11) (8) (4) (1) c. (5) (12) d. (9) (1) (6)

已知L是带表头结点的非空单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。 a. 删除P结点的直接后继结点的语句序列是____________________。

b. 删除P结点的直接前驱结点的语句序列是____________________。

c. 删除P结点的语句序列是____________________。 d. 删除首元结点的语句序列是____________________。 e. 删除尾元结点的语句序列是____________________。 (1) P=P->next; (2) P->next=P;

(3) P->next=P->next->next; (4) P=P->next->next;

(5) while(P!=NULL) P=P->next;

(6) while(Q->next!=NULL) { P=Q; Q=Q->next; } (7) while(P->next!=Q) P=P->next; (8) while(P->next->next!=Q) P=P->next; (9) while(P->next->next!=NULL) P=P->next; (10) Q=P; (11) Q=P->next; (12) P=L; (13) L=L->next; (14) free(Q); 解：a. (11) (3) (14)

b. (10) (12) (8) (3) (14) c. (10) (12) (7) (3) (14)

d. (12) (11) (3) (14) e. (9) (11) (3) (14)

已知P结点是某双向链表的中间结点，试从下列提供的答案中选择合适的语句序列。 a. 在

P

结点后插入

S

结点的语句序列是

_______________________。 b. 在

P

结点前插入

S

结点的语句序列是

_______________________。

c. 删除P结点的直接后继结点的语句序列是_______________________。

d. 删除P结点的直接前驱结点的语句序列是_______________________。

e. 删除P结点的语句序列是_______________________。 (1) P->next=P->next->next; (2) P->priou=P->priou->priou; (3) P->next=S; (4) P->priou=S; (5) S->next=P; (6) S->priou=P; (7) S->next=P->next; (8) S->priou=P->priou; (9) P->priou->next=P->next;

(10) P->priou->next=P; (11) P->next->priou=P; (12) P->next->priou=S; (13) P->priou->next=S; (14) P->next->priou=P->priou; (15) Q=P->next; (16) Q=P->priou; (17) free(P); (18) free(Q);

解：a. (7) (3) (6) (12)

b. (8) (4) (5) (13) c. (15) (1) (11) (18) d. (16) (2) (10) (18) e. (14) (9) (17)

简述以下算法的功能。

(1)

Status

A(LinkedList

L)

{ Aa1,,amBb1,,bnABABABABABABABABABa1,,anan,,a1Aa1,a2,,amBb1,b2,,bnCa1,b1,,am,bm,bm1,,bnmnCa1,b1,,an,bn,an1,,ammnLa1,a2,,anLa1,a3,,an,,a4,a2.,an)改造为

(a1,a3,...,an,...,a2)

Status ListChange_DuL(DuLinkList &L)

{

int i;

DuLinkList p,q,r; p=L->next; r=L->pre; i=1; while(p!=r){

if(i%2==0){

q=p; p=p->next;

Pnxc1xe1c2xe2cmxemnemem1e10ci0i1,2,,mm1Pnx0x0PxPn1xPn2xp1p2pnpjpkpipjpkpipjpkpipipjpkpjpkpi

2n1olor;

Push(s,g[][]); while(!StackEmpty(s)){

Pop(s,e); CurPos=;

g[][].Color=FillColor; g[][].Visited=1;

ifPush(s,g[+1][]);

!g[+1][].Visited && g[+1][].Color==OldColor

if>0 && )

Push(s,g[][]); !g[][].Visited && g[][].Color==OldColor

}

}

ifPush(s,g[][+1]); !g[][+1].Visited && g[][+1].Color==OldColor

if>0 && )

Push(s,g[][]); !g[][].Visited && g[][].Color==OldColor

void CreateGDS(ElemType g[M][N]) {

int i,j; for(i=0;ifor(j=0;jg[i][j].=i; g[i][j].=j; g[i][j].Visited=0; g[i][j].Color=0;

}

}

for(i=2;i<5;i++)

for(j=2;j<4;j++)

g[i][j].Color=3;

for(i=5;ifor(j=3;j<6;j++)

g[i][j].Color=3;

void ShowGraphArray(ElemType g[M][N]) { }

假设表达式有单字母变量和双目四则运算符构成。试写一个算法，将一个通常书写形式且书写正确的表达式转换为逆波兰表达式。

解： .#格式

int i,j;

for(i=0;ifor(j=0;jcout<cout<void InversePolandExpression(char Buffer[]) {

Push(s,Buffer[i]); i++;

while(Buffer[i]!='#'){

if(!IsOperator(Buffer[i])){Stack s; InitStack(s); int i=0,j=0; ElemType e;

0m0,n0 gm,ngm1,2nnm0,n0

n1FnnFn2

p2Aep2Aen0n0ApsqrtA,p,e1AsqrtA,p,e2pfnmaxn1m0akmm,nakmm1,1m0,n0akmm1,akmm,n1m0,n0fn1maxka(a1)i(i1)11bkni(nj)1i1j1ijf1(i)(n)ii22222c(n1)f(j)jij10k3n1n2n2n2n2

as(n)s(n1)ans(n1)a1(n1)dadd(a,b)add(a,b)b0b0.

，总共需进行n-k次交换。注意最后一组可能出现不足k个元素的情况，此时最后一组为剩余元素加第一组的前几个元素共k个构成最后一组。

void RRMove(ElemType A[],int k,int n) { } 解： #include <> #define RS 4 #define CS 4

ElemType e; int i=0,j,p; while(ip=i/k+1;

for(j=0;je=A[j];

A[j]=A[(p*k+j)%n]; A[(p*k+j)%n]=e; i++;

typedef int ElemType; typedef struct{

ElemType e; int i,j; int Flags;

}NodeType;

void Initialize(NodeType a[RS][CS],ElemType A[RS][CS]); void SaddlePoint(NodeType a[RS][CS]); ElemType RowMin(NodeType a[RS][CS],int k); ElemType ColMax(NodeType a[RS][CS],int k); void Show(NodeType a[RS][CS]);

int main() {

ElemType A[RS][CS]={ };

{2,1,3,4}, {1,3,1,2}, {2,7,1,3}, {3,2,4,1}

}

NodeType a[RS][CS]; Initialize(a,A); SaddlePoint(a); Show(a); return 0;

void Initialize(NodeType a[RS][CS],ElemType A[RS][CS]) { }

void SaddlePoint(NodeType a[RS][CS]) {

int i,j;

for(i=0;ifor(j=0;ja[i][j].e=A[i][j]; a[i][j].i=i; a[i][j].j=j; a[i][j].Flags=0;

}

int i,j; ElemType x,y; for(i=0;ix=RowMin(a,i); for(j=0;jy=ColMax(a,j);

if(a[i][j].e==x&&a[i][j].e==y)

a[i][j].Flags=1;

ElemType RowMin(NodeType a[RS][CS],int k) {

ElemType x; x=a[k][0].e; int i;

for(i=1;iif(x>a[k][i].e){ }

x=a[k][i].e;

return x;

}

ElemType ColMax(NodeType a[RS][CS],int k) { }

void Show(NodeType a[RS][CS]) { } 解：

for(int i=0;ifor(int j=0;jif(a[i][j].Flags)

cout<ElemType x; x=a[0][k].e; int i;

for(i=1;iif(xx=a[i][k].e;

return x;

typedef int ElemType; class Triple{ public: };

BOOL Triple::operator<(Triple b) { }

BOOL Triple::operator==(Triple b) {

if(row== && col== if(row< return TRUE; if(row==&&col< return TRUE; return FALSE; int row; int col; ElemType e;

Triple(){}

virtual ~Triple(){} BOOL operator<(Triple b); BOOL operator==(Triple b);

}

return TRUE;

else

return FALSE;

class CSparseMat { public: }

void CSparseMat::ShowSparse(CDC *pDC)

Triple *m_pt; ow=; }

}

m_pt[i].col=; m_pt[i].e=;

CSparseMat(){}

virtual ~CSparseMat(){} CSparseMat(int r,int c,int n); CSparseMat operator+(CSparseMat B); void ShowSparse(CDC* pDC);

{ }

ow=m_pt[i].row;

} else{

if(m_pt[i]==[j]){ [k].col=m_pt[i].col; [k].e=m_pt[i].e; i++;

char str[10]; int k=0;

for(int i=0;ifor(int j=0;jif(m_pt[k].row==i && m_pt[k].col==j){ }

else itoa(0,str,10);

pDC->TextOut(0+j*20,0+i*20,str,strlen(str));

itoa(m_pt[k].e,str,10); k++;

}

}

}

[k].row=m_pt[i].row; [k].col=m_pt[i].col; [k].e=m_pt[i].e+[j].e; i++; j++;

else{ }

[k].row=[j].row; [k].col=[j].col; [k].e=[j].e; j++;

k++;

while(i[k].row=m_pt[i].row; [k].col=m_pt[i].col; [k].e=m_pt[i].e; i++; k++;

}

}

[k].row=[j].row; [k].col=[j].col; [k].e=[j].e; j++; k++;

=k;

return temp;

解： #include<> #include<> #define Max 128

typedef int ElemType; typedef struct{

int col; ElemType e;

}Twin;

class CSparseMat {

public:

Twin* m_pt; ol>>m_pt[i].e; }

for(i=0;icout<<\"请输入每行第一个非零元在二元组中的序号(没有输CSparseMat(){}

CSparseMat(int r,int c,int n); virtual ~CSparseMat(){} void ShowSparse(int i,int j);

入-1)：\"; }

int main() {

CSparseMat A(3,3,5); }

cout<cin>>rpos[i]; ol==j) }

x=m_pt[k].e;

k++;

}

(2,1); return 0;

解：

typedef int ElemType; typedef struct OLNode{

int row; int col; ElemType e;

struct OLNode *right,*down;

}OLNode,*OLink;

class CCrossListMat { public:

OLink

kH1k1pk2ikn1n2nk*RHead,*CHead;

1n12n23n3...knkkn01n12n23n3...knk(n1n2n3...nk)1(i1)nii1nkn1nkkn0nnknn1h1logk(n(k1)1)n0n1n0k1n11n0kkn0(k1)n11n0kh1k1kn1kh1n1n00n0k1k1kH11kH1nk1k13H112n3H12n13H3(2n1)log3(2n1)H1log3(2n1)Hlog3(2n1)n113n1nn0n1nn31n0Hlog3(3n0)1log3n0222i1nli11li12n1(lp1)n1nn112n1l112(l11)1lp12(l11)2(l21)...22(l11)2(l21)...2...2(ln1)12(lp11)(lp11)...2(ln1)2(lp11)2(lp11)2(l11)2(l21)...2(lp1)...2(ln1)1k12n mn . .。

解：邻接表：

邻接多重表：

深度优先搜索的顺序为 1 5 6 4 3 2

广度优先搜索的顺序为 1 5 6 3 2 4，

15 16 13 12 24

解：

Status CreateAG(ALGraph &G) { int n,e,k,i,j;

cout<<\"请输入顶点数：\"; cin>>n;

cout<<\"请输入边数：\"; cin>>e; =n; =e;

ata; [k].firstarc=NULL; } irstarc; if(!q) [i].firstarc=p; else{

while(q->nextarc) q=q->nextarc; if[i].data==v) return i; else return -1;

}

ata!=v&&i< i++; 解

第9章 查找

解：(1)相同，平均查找长度为(n1) (2)相同，平均查找长度为(n1) (3)对于有序顺序表，平均查找长度为则为(n1)。

解：查找e的过程如下： 解：ASL 解：ASL 解：ASL

解：a111122344

a111122344

a212132445

3412nk1，对于无序顺序表，2121112243342.9 10112243845678935.68 50112243745563.8 20 an1n1(n1)2(n2)4(n3)

sNan8N17n1n1NN8N(N1)17N 2 ASLN117 28 解：(1) ASL

11122333425163.5 12 (3)