西电C++面向对象程序设计软件技术基础课后答案 2.docx

西电C++面向对象程序设计软件技术基础课后答案 2.docx

《西电C++面向对象程序设计软件技术基础课后答案 2.docx》由会员分享，可在线阅读，更多相关《西电C++面向对象程序设计软件技术基础课后答案 2.docx（20页珍藏版）》请在冰豆网上搜索。

西电C++面向对象程序设计软件技术基础课后答案2

软件技术基础习题答案

习题3

四、1

intcompare（SeqList*La,SeqList*Lb）

{

inti;

i=1;

while（i<=La->last&&i<=Lb->Last&&La->data[i]==Lb->data[i]）

i++;

if（i<=La->last&&j>Lb->last||La->data[i]>Lb->data[i]）return1;//A>B

if（i>La->last&&j<=Lb->last||La->data[i]data[i]）return-1;//A

if（i>La->last&&j>Lb->last）

return0;//A=B

}

四、2

（1）顺序表

intinvert（SeqList*L）

{

inti=1;

datatypetemp;

while（i<=L->last/2）

{

temp=L->data[i];

L->data[i]=L->data[L->last-i+1];

L->data[L->last-i+1]=temp;

}

}

（2）链表

voidinvert（linklist*head）

{

linklist*p,*q,*r;

p=head->next;

q=p->next;

while（q!

=NULL）

{

r=q->next;

q->next=p;

p=q;

q=r;

}

head->next->next=NULL;

head->next=p;

}

四、5

voidmergelist（Linear_list*La,Linear_list*Lb,Linear_list*&Lc）

{

Lc=（Linear_list*）malloc（sizeof（Linear_list））;//产生C表的头结点头插法

Lc->next=NULL;

while（La->next!

=NULL&&Lb->next!

=NULL）//La、Lb均非空

if（La->next->data<=Lb->next->data）

{

p=La->next;

La->next=La->next->next;

insert（Lc,p）;

}

else

{

p=Lb->next;

Lb->next=Lb->next->next;

insert（Lc,p）;

}

while（La->next!

=NULL）

{

p=La->next;

La->next=La->next->next;

insert（Lc,p）;

}

while（Lb->next!

=NULL）

{

p=Lb->next;

Lb->next=Lb->next->next;

insert（Lc,p）;

}

}//O（Length（La）+Length（Lb））

voidinsert（Linear_list*Lc,Linear_list*p）

{

p->next=Lc->next;

Lc->next=p;

}//O

（1）

四、8

voiddeleteFront（Link*s）

{

Link*p=s,*q;

while（p->next->next!

=s）p=p->next;

q=p->next;

p->next=s;

free（q）;

}

习题4

四、1

intsymmetry（linklist*head,stack*s）

//具有头结点的单链表中存放有一个字符串，每个结点的数据域存放一个字符。

//head为单链表的头指针，s为栈的结构体指针

{

intn=length（head）/2;

linklist*p=head->next;

datatypex;

for（inti=0;i

push（s,p->data）;

p=p->next;

}

if（length（head）%2==1）p=p->next;

while（p!

=NULL）{

x=pop（s）;

if（x==p->data）p=p->next;

elsereturn0;

}

return1;

}

四、3

voiddelete（Stack*s）

{

Stack*temp;

datatypex;

InitS（temp）;

while（!

EmptyS（s））

{

x=Pop（s）;

if（x!

=m）Push（temp,x）;

}

while（!

Empty（temp））

Push（s,Pop（temp））;

}

四、4

intcorrect（char*exp）

{

InitStack（S）;

intflag=1;

i=0;

while（exp[i]!

='\0'&&flag）

{

if（exp[i]=='（'||exp[i]=='['||exp[i]=='{'）Push（S,exp[i]）;//遇左括号入栈

if（exp[i]=='）'）if（Pop（S）!

='（'）flag=0;

if（exp[i]==']'）if（Pop（S）!

='['）flag=0;

if（exp[i]=='}'）if（Pop（S）!

='{'）flag=0;

//遇右括号出栈，若栈顶不是左括号，则括号不配对

i++;

}

if（!

Empty（S））flag=0;//若栈非空，则括号不配对

returnflag;

}

四、6

循环队列的结构类型定义：

constintm=5;

typedefintdatatype;

typedefstruct

{datatypesequ[m];

intrear,quelen;

}qu;

说明：

队满条件：

sq->quelen==m队空条件：

sq->quelen==0（注意：

不需要空出一个位置）

入队：

voidenqueue（qu*sq,datatypex）

{if（sq->quelen==m）printf（"queueisfull"）;

else{sq->quelen++;

sq->rear=（sq->rear+1）%m;//修改队尾指针

sq->sequ[sq->rear]=x;

}

}

出队：

intdequeue（qu*sq,datatype&x）

{if（sq->quelen==0）

{printf（"queueisempty"）;return0;}

else{sq->quelen--;

x=sq->sequ[（sq->rear-sq->quelen+m）%m];

return1;

}

}

习题5

四、3

（1）顺序串

intEqual（SeqString*S,SeqString*T）

//比较顺序串S、T是否相等

{i=0；

while（（S->ch[i]==T->ch[i]）&&（ilength）&&（ilength））i++;

if（（i==S->length）&&（i==T->length））return1;

elsereturn0;

}

（2）链串

intEqual（LinkString*S,LinkString*T）

//比较链串S、T是否相等

{

p=S->next；q=T->next;

while（（S->data==T->data）&&（p!

=NULL）&&（q!

=NULL））

{

p=p->next;

q=q->next;

}

if（（p==NULL）&&（q==NULL））return1;

elsereturn0;

}

四、7

voidstrDelete（char*S,inti,intm）

{

chartemp[80];intk;

k=i-1;

if（i>=strlen（S））return;

else

{

strncpy（temp,S,k）;

if（k+m>=strlen（S））strcpy（temp+k,"\0"）;

elsestrcpy（temp+k,S+k+m）;

strcpy（S,temp）;

}

}

或者：

voidstrDelete（seqstring*S,inti,intm）

//字符串中字符的序号从1开始，数组元素从下标0开始使用

{

chartemp[maxsize];

if（i<=S->len）{

strncpy（temp,S->str,i-1）;//将S->str中第i个字符之前的i-1个字符复制到temp中

strcpy（temp+i-1,S->str+i+m-1）;//将S->str中第i+m个字符开始的字符连接到temp

之后

strcpy（S->str,temp）;//将temp复制到S->str中

if（i<=S->len）

if（i+m-1<=S->len）S->len=S->len-m;//删除了字符串中间的部分字符

elseS->len=i-1;//删除了字符串中从第i个字符开始的全部字符

}

}

四、9

voidcreate（Spmatrix*a）

{

scanf（"%d,%d,%d",&a->m,&a->n,&a->t）;

for（ano=0;anot;ano++）

scanf（"%d,%d,%d",&a->data[ano].i,&a->data[ano].j,&a->data[ano].v）;

}

四、11

voidminmax（array*p）

//找马鞍点

{inti,j,have=0;

for（i=0;i

{p->min[i]=p->A[i][0];

for（j=1;j

if（p->A[i][j]min[i]）p->min[i]=p->A[i][j];

}//分别找出m行的最小值

for（j=0;j

{p->max[j]=p->A[0][j];

for（i=1;i

if（p->A[i][j]>p->max[j]）p->max[j]=p->A[i][j];

}//分别找出n列的最大值

for（i=0;i

for（j=0;j

if（p->min[i]==p->max[j]）//若相等，则是一个马鞍点

{cout<A[i][j]<

have=1;

}

if（!

have）cout<<"矩阵中没有马鞍点！

\n";

}

第六章

四4、知二叉树的后序序列DECBGIHFA和中序序列为DCEBAFHGI，画出这棵二叉树。

A

BF

C　　　　H

DEI

G

7、右交换子树算法（在上机答案）

//交换左右子树

bitree*swap（bitree*p）

{bitree*t1,*t2;

if（p!

=NULL）

{1=swap（p->lchild）;

t2=swap（p->rchild）;

p->lchild=t2;

p->rchild=t1;

}

returnp;

}

12、已知结点序列{21，18，37，42，65，24，19，26，45，25}，画出相应的二叉排序树，并画出删除结点37后的二叉排序树。

有问题

（1）

（2）删除结点37后

14某密码电文由8个字母组成，每个字母在电文中的出现频率分别是7、19、2、6、32、3、21、10，试为这8个字母设计相应的哈夫曼编码。

解：

这8个字母可用A、B、C、D、E、F、G、H表示

组成的哈夫曼编码如下所示。

A：

1001B：

101C：

0010D：

1000

E：

11F：

0011G：

01H：

000

设计的哈夫曼树如下：

哈夫曼树

第7章

四、4、邻接表:

126null

2136null

324null

435null

547null

6127null

756null

DFS:

1234576BFS:

1263745（不唯一）或1627354

5、按顺序输入后的邻接表:

126435null

216null

3145null

41635null

56413null

61245null

6、从顶点4开始:

DFS:

412653（有多种）

BFS:

413562（不唯一）

7最小生成树:

7

6

1

5

24

3

第8章

4、查找586

12345678910111213141516

687155188150465505508511586656670700766897908

Low=1high=16mid=（1+16）/2=8R[8]＝508<586

Low=mid+1=9high=16mid=（9+16）/2=12R[12]=670>586

Low=9high=12-1=11mid=（9+11）/2=10R[10]=586

586=R[10]查找成功

5线性探查13

HT

0

1

2

3

4

5

6

7

8

9

10

11

12

52

26

15

120

43

11

84

70

99

92

37

25

H（key）

0

0

2

3

4

11

6

2

8

4

11

12

比较

1

2

1

1

1

8

1

6

1

6

1

1

拉链

0

52，26

1

2

15，70

3

120

4

43，82

5

6

84

7

8

99

9

10

11

37，11

12

25

给定关键字序列为（105，50，30，25，85，40，100，12，10，28，分别写出直接插入排序、希尔排序、起泡排序、直接选择排序、快速排序和归并排序的每一趟运行结果。

直接插入排序：

初始关键字序列：

105，50，30，25，85，40，100，12，10，28

第一趟直接插入排序：

【50，105】

第二趟直接插入排序：

【30，50，105】

第三趟直接插入排序：

【25，30，50，105】

第四趟直接插入排序：

【25，30，50，85，105】

第五趟直接插入排序：

【25，30，40，50，85，105】

第六趟直接插入排序：

【25，30，40，50，85，100，105】

第七趟直接插入排序：

【12，25，30，40，50，85，100，105】

第八趟直接插入排序：

【10，12，25，30，40，50，85，100，105】

第九趟直接插入排序：

【10，12，25，28，30，40，50，85，100，105】

希尔排序（增量为5，3，1）：

初始关键字序列：

105，50，30，25，85，40，100，12，10，28

第一趟希尔排序：

40，50，12，10，28，105，100，30，25，85

第二趟希尔排序：

10，28，12，40，30，25，85，50，105，100

第三趟希尔排序：

10，12，25，28，30，40，50，85，100，105

起泡排序：

初始关键字序列：

105，50，30，25，85，40，100，12，10，28

第一趟起泡排序：

10，105，50，30，25，85，40，100，12，28

第二趟起泡排序：

10，12，105，50，30，25，85，40，100，28

第三趟起泡排序：

10，12，25，105，50，30，85，40，100，28

第四趟起泡排序：

10，12，25，28，105，50，30，85，40，100

第五趟起泡排序：

10，12，25，28，30，105，50，85，40，100

第六趟起泡排序：

10，12，25，28，30，40，105，50，85，100

第七趟起泡排序：

10，12，25，28，30，40，50，105，85，100

第八趟起泡排序：

10，12，25，28，30，40，50，85，105，100

第九趟起泡排序：

10，12，25，28，30，40，50，85，100，105

直接选择排序：

初始关键字序列：

105，50，30，25，85，40，100，12，10，28

第一趟选择排序：

10，50，30，25，85，40，100，12，105，28

第二趟选择排序：

10，12，30，25，85，40，100，50，105，28

第三趟选择排序：

10，12，25，30，85，40，100，50，105，28

第四趟选择排序：

10，12，25，28，85，40，100，50，105，30

第五趟选择排序：

10，12，25，28，30，40，100，50，105，85

第六趟选择排序：

10，12，25，28，30，40，50，100，105，85

第七趟选择排序：

10，12，25，28，30，40，50，85，100，105（完成）

第八趟选择排序：

10，12，25，28，30，40，50，85，100，105

第九趟选择排序：

10，12，25，28，30，40，50，85，100，105

快速排序：

初始关键字序列：

105，50，30，25，85，40，100，12，10，28

第一趟快速排序：

（28，50，30，25，85，40，100，12，10），105

第二趟快速排序：

（10，12，25），28，（85，40，100，30，50），105

第三趟快速排序：

10，12，25，28，（50，40，30），85，（100），105

第四趟快速排序：

10，12，25，28，（30，40），50，85，100，105

第五趟快速排序：

10，12，25，28，（30，40），50，85，100，105

归并排序：

初始关键字序列：

105，50，30，25，85，40，100，12，10，28

第一趟归并排序：

50，105，25，30，40，85，12，100，10，28

第二趟归并排序：

25，30，50，105，12，40，85，100，10，28

第三趟归并排序：

10，12，25，28，30，40，50，85，100，105

设待排序的关键字序列为（15，21，6，30，23，6′，20，17），试分别写出使用以下排序方法每趟排序后的结果。

并说明做了多少次比较。

（1）直接插入排序

（2）希尔排序（增量为5，2，1）（3）起泡排序

（4）快速排序（5）直接选择排序（6）锦标赛排序

（7）堆排序（8）二路归并排序（9）基数排序

【解答】

（2）希尔排序（增量为5，2，1）

初始关键字序列：

15，21，6，30，23，6′，20，17

第一趟希尔排序：

6′，20，6，30，23，15，21，17

第二趟希尔排序：

6′，15，6，17，21，20，23，30

第三趟希尔排序：

6′，6，15，17，20，21，23，30

（3）起泡排序

初始关键字序列：

15，21，6，30，23，6′，20，17

第一趟起泡排序：

15，6，21，23，6′，20，17，30

第二趟起泡排序：

6，15，21，6′，20，17，23，30

第三趟起泡排序：

6，15，6′，20，17，21，23，30

第四趟起泡排序：

6，6′，15，17，20，21，30，23

第五趟起泡排序：

6，6′，15，17，20，21，30，23

（4）快速排序

初始关键字序列：

15，21，6，30，23，6′，20，17

第一趟快速排序：

【6′，6】15【30，23，21，20，17】

第二趟快速排序：

6′，6，15【17，23，21，20】30

第三趟快速排序：

6′，6，15，17【23，21，20】30

第四趟快速排序：

6′，6，15，17，【20，21】23，30

第五趟快速排序：

6，6′，15，17，20，21，30，23

（5）直接选择排序

初始关键字序列：

15，21，6，30，23，6′，20，17

第一趟直接选择排序：

6，21，15，30，23，6′，20，17

第二趟直接选择排序：

6，6′，15，30，23，21，20，17

第三趟直接选择排序：

6，6′，15，30，23，21，20，17

第四趟直接选择排序：

6，6′，15，17，23，21，20，30

第五趟直接选择排序：

6，6′，15，17，20，21，23，30

第六趟直接选择排序：

6，6′，15，17，20，21，23，30

第七趟直接选择排序：

6，6′，15，17，20，21，23，30

（6）锦标赛排序

初始关键字序列：

15，21，6，30，23，6′，20，17（此题答案的格式不对，我删去了）

锦标赛排序的基本思想是：

首先对n个待排序记录的关键字进行两两比较，从中选出n/2个较小者再两两比较，直到选出关键字最小的记录为止，此为一趟排序。

我们将一趟选出的关键字最小的记录称为“冠军”，而“亚军”是从与“冠军”比较失败的记录中找出，具体做法为：

输出“冠军”后，将（冠军）叶子结点关键字改为最大，继续进行锦标赛排序，直到选出关键字次小的记录为止，如此循环直到输出全部有序序列。

上面给出了排在前三个的记录，详细过程略。

（7）堆排序

初始关键字序列：

15，21，6，30，23，6′，20，17

初始堆：

6，17，6’，21，23，15，20，30

第一次调堆：

6’，17，15，21，23，30，20，【6】

第二次调堆：

15，17，20，21，23，30，【6’，6】

第三次调堆：

17，21，20，30，23，【15，6’，6】

第四次调堆：

20，21，23，30，【17，15，6’，6】

第五次调堆：

21，30，23，【20，17，15，6’，6】

第六次调堆：

23，30，【21，20，17，15，6’，6】

第七次调堆：

30，【23，21，20，17，15，6’，6】

堆排序结