数据结构(Java版)习题解答

A
I N D E X
练习题答案
第一章练习题答案(a) n+(n–1)+(n–2)+…+2+1
=
2)1
(+ n n (b) n+(n–1)+(n–2)+…+2+1
=
2
)1
(+
n
n
f(n)≦c.g(n) →f(n)=O(g(n))
(a) f(n)=100n+9
c=101, g(n)=n, n0=10
得知f(n)=O(n)
(b) f(n)=1000n2+100n–8
c=2000, g(n)= n2, n0=1
得知f(n)=O(n2)
(c) f(n)=5*2n+9 n2+2
c=10, n0=5
得知f(n)=O(2n)
f(n)≧c g(n) →f(n)=Ω(g(n)) (a) f(n)=3n+1
c=2, n0=1, g(n)=n
得知f(n)=Ω(n)(b) f(n)=100n2+4n+5
c=10, n0=1, g(n)= n2
得知f(n)=Ω(n2)
(c) f(n)=8*2n+8n+16
c=8, n0=1, g(n)= 2n
得知f(n)=Ω(n2)
c1.g(n)≦f(n)≦c2.g(n) →f(n)= Θ(g(n))
(a) f(n)=3n+2
c1=3, c2=6, n0=1
得知f(n) = Θ (n)
(b) f(n)=9n2+4n+2
c1=9, c2=16, n0=1
得知f(n) = Θ (n2)
(c) f(n)=8n4+5n3+5
c1=8, c2=20, n0=1
得知f(n) = Θ (n4)
A-2
练习题解答
第二章练习题答案
1. 分别以行为主和以列为主说明之。

(a) 以行为主
A(i, j)=l0+(i–1)*u2*d+(j–1)*d
(b) 以列为主
A(i, j)=l0+(j–1)*u1*d+(i–1)*d
2. 以列为主
A(i, j)=l0+(j–12)*md+(i–l1)d
m=u1–l1+1=5–(–3)+1=9
m=u2–l2+1=2–(–4)+1=7
A(1, 1) =100+(1–(–4))*9+(1–(–3))
=100+45+4=149
3. 分别以行为主和以列为主的说明。

由于数组为A(1：u1, 1：u2, 1：u3)，因此p = u1-l1+1, q = u2- l2+1, r = u3- l3+1 所以p = u1-1+1 = u1, q = u2-1+1 = u2, r = u3-1+1 = u3
(a) 以行为主
A(i, j, k)=l0 + (i–1)*u2*u3*d + (j–1)*u3*d +(k-1)
(b) 以列为主
A(i, j, k)=l0 + (k–1)*u1*u2*d + (j–1)*u1*d + (i-1)*d
4. 以列为主：A(i, j, k)=l0 + (k–l3)*pqd + (j–l2)*pd + (i-l1)*d
p = 5-(-3) + 1 = 9, q = 2-(-4)+1 = 7, r = 5-1+1 = 5
A(2, 1, 2) = 100 + (2-1)*9*7*1 + (1-(-4))*9*1 + (2-(-3))*1
= 100 + 63 + 45 + 5 = 253
A-3
5. 以行为主：
A(i1, i2, i3, …, i n) = l0 +(i1–1)u2u3…u n
+(i2–1)u3u4…u n
+(i3–1)u4u5…u n
…
+(i n–1)
以列为主：
A(i1, i2, i3, …, i n)=l0+(i n–1)u1u2…u n-1
+(i n-1–1)u1u2…u n-2
+(i3–1)u4u5…u n
…
+(i2–1)*n1
+(i1–1)
2.2节练习题答案
1.
(a) 由上图知ptr+2为a[2]元素的地址，所以*(ptr+2)和a[2]表示的结果
是一样的，其值为2。

A-4
练习题解答
(b) a为指针常数，但ptr为指针变量，所以ptr可以用于递增或递减的
运算符，如ptr++，或ptr––，但a就不能使用此运算符，因为常数
不可以当做LVALUE。

2. // file name: binary_search.java
import java.io.*;
public class binary_search
{
static int[] A= {-9999,2,4,6,8,10,12,14,16,18,20};
static int count=0;
public static int binary_search(int key)
{
int i=1;
int j=10;
int k;
count=0;
do{
count++;
k = (i+j)/2;
if(A[k] == key)
break;
else if(A[k] < key)
i = k+1;
else
j = k-1;
}while(i<=j);
return count;
}
public static void main (String args[]) // 主函数
{
binary_search myApp = new binary_search();
System.out.println("Search 1, " + myApp.binary_search(1) +" times");
System.out.println("Search 3, "+ myApp.binary_search(3) + " times");
System.out.println("Search 13, "+ myApp.binary_search(13) + " times");
A-5
System.out.println("Search 21, "+ myApp.binary_search(21) + " times");
System.out.println("Total " + (myApp.binary_search(1)
+ myApp.binary_search(3)+ myApp.binary_search(13)
+ myApp.binary_search(21)) + " times");
}
}
// file name: sparse_matrix.java */
import java.io.*;
public class sparse_matrix
{
//存储稀疏矩阵的数据结构预设10 - 1 = 9 个元素
static int[][] sm = new int[10][3];
static int sm_row=1;
static final int width = 6;
static final int height = 6;
static int[][] source=
{ {0,15, 0, 0,-8, 0},
{0, 0, 6, 0, 0, 0},
{0, 0, 0,-6, 0, 0},
{0, 0,18, 0, 0, 0},
{0, 0, 0, 0, 0,16},
{72, 0, 0, 0,20, 0}
};
static int row=0,col=0;
static int non_zero=0;
public static void scan_matrix()
{
System.out.println("Scan the matrix...");
while (row < height && col < width) {
if(source[row][col] !=0){
non_zero++; //计算非零元素个数
A-6
练习题解答
sm[sm_row][0] = row+1;
sm[sm_row][1] = col+1;
sm[sm_row][2] = source[row][col];
sm_row++;
}
if(col == width-1){ //先扫单一列上所有元素
row++;
if(row <= height-1) //当扫到最后一列就不归零
col=0;
}
else
col++;
}
System.out.println("Total nonzero elements = " + non_zero);
//稀疏矩阵数据结构信息
sm[0][0] = row;
//最后col停在数组编号最后一个元素,换成个//数要加1
sm[0][1] = col+1;
sm[0][2] = non_zero;
}
public static void output_sm(int non_zero_)
{
int i,j;
System.out.println(" 1\\) 2\\) 3\\)");
System.out.println("----------------------");
for(i=0 ; i <= non_zero_ ;i++){
System.out.print("A\\(" + i + ",");
for(j=0 ; j < 3; j++)
System.out.print(" "+ sm[i][j]);
System.out.println("");
}
}
public static void main(String args[])
A-7
A-8
{ sparse_matrix myApp = new sparse_matrix(); myApp.scan_matrix();
myApp.output_sm(non_zero);
} }
1.
(a) 使用n+2长度存储
p=(7, 6, 0, 8, 5, 0, 3, 0, 7) (b) 只考虑非零项
p=(5, 7, 6, 5, 8, 4, 5, 2, 3, 0, 7)
2.
⎥
⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢
⎢⎢⎢
⎣⎡-000
6300002000080000900
035432103
210x x x x x x y y y y 以下的算法以行为主 (a) 存储
for(i=1;i<=n;i++) for(j=1;j<=n;j++){ k=n(i –1)-i(i-1)/2+j B[k]=A[i, j]; } (b) 提取
练习题解答
if(i>j)
p=0;
else {
k=n(i-1)-i(i-1)/2+j;
p=B[k];
}
第三章练习题答案
由于堆栈和队列都属于顺序列表，因此可利用数组(array)的数据结构表示，而
注标值表示最大的容量。

3.2节练习题答案
若top的初值为0，则push和pop函数分别如下
A-9
pulbic static void push_f()
{
DataInputStream in = new DataInputStream(System.in);
if(top > MAX)
System.out.println(” Stack is full !”);
else {
top++;
System.out.print("\n Please enter item to insert: ");
System.out.flush();
try {
item[top] = in.readLine();
} catch (IOException e) {}
}
System.out.println("");
}
public static void pop_f() { // 删除函数
if(top < 0) // 当堆栈没有数据存在，则显示错误
System.out.print("\nNo item, stack is empty !\n");
else {
System.out.print("\nItem " + item[top] + " deleted !\n");
top--;
}
System.out.println("");
}
中序→后序
(1) a > b && c > d && e < f
(a > b) && (c > d) && (e < f)
(((a > b) && (c > d)) && (e < f))
a b > c d > && e f < &&
(2) (a + b) * c / d + e – 8
((a + b) * c ) / d + e – 8
((((a + b) * c) / d) + e) – 8
A-10
a b + c * d / e + 8 –
第四章 练习题答案
1. 有一链表如下：
this=head;
while(this.next != null){// 寻找链表最后节点 p rev=this; // prev 紧跟随在this 之后 this=this.next;
｝
prev.next=null; this = null; 2.
(a) current (b) current 将指到链表节点的尾端
(a) 先追踪A ，B 两个循环链表的尾端
atail = A;
while(atail.next != A) atail = atail.next;
A
atail
head
btail = B;
while(btail.next != B)
btail = btail.next;
(b) 将B 指针指到的节点指定给atail.next ，并将A 指针指到的节点指定给
btail.next ，如下所示： atail.next = B;
btail .next = A; 1.
new.rlink = x.rlink; x.rlinkllink = new; new.llink = x;. x.rlink = new;
2.
head.rlink = x.rlink; x.rlink.llink = head; x = null;
1.
有一环状链表如下所示：
由于堆栈的特点为先进先出，又由于循环链表以哪一节点为前端都可以，因此假设上图的head 所指向的为前端节点，即每次加入的节点为前端，删除则从前端删除。

增加的操作为
new.next = head;
tail
head
tail.next = new;
head = new;
删除的操作：
this = head;
head = head.next;
tail.next = head;
this = null;
若此循环链表没有tail指针时，则需遍历。

第五章练习题答案
(1) 递归方法求gcd
public static int gcd(int in, int n)
{
int temp;
temp + m%n;
if(temp == 0)
return m;
else {
m = n;
n = temp;
gcd(m, n);
}
}
(2) 非递归的方式求gcd
public static int gcd (int m, int n)
{
int temp,
temp = m%n;
while (temp != 0){
m = n;
n = temp;
temp = m%n;
}
return m;
}
5.4节练习题答案
A B C move 1 from A to B
move 2 from A to C
move 1 from B to C
move 3 from A to B
move 1 from C to A
move 2 from C to B
move 1 from A to B
move 4 from A to C
move 1 from B to C
move 2 from B to A
move 1 from C to A
move 3 from B to C
move 1 from A to B
move 2 from A to C
move 1 from B to C
第六章练习题答案
❝❝❝【6.1节练习题答案】
共需8*25=200个links
但实际用了24个links
故浪费了(200－24)=176个links
❝❝❝【6.2节练习题答案】
1. (1) Yes, (2) No, 3) No.
2. (1) 28－1=256－1=255
(2) 26-1=25=32
3. 128－1=127(根据n0=n2+1)
❝❝❝【6.3节练习题答案】
以下是用一维数组来存储三叉树的节点表示法
1st level 2nd
level
3rd
level
4th
level
共1个节点共3个节点共9个节点共34-1=27个节点
先序遍历：a，b，d，h，e，c，f，i，g
中序遍历：d，h，b，e，a，f，i，c，g
后序遍历：h，d，e，b，i，f，g，c，a
…
30
20
10
15 5 25 50
40
60
45 13
3
30
20
10 15 5
25 60
40
45
13
3
6.5节练习题答案1.
2. 加入3和13之后的二叉查找树如下：
删除50之后的二叉查找树如下：（此答案乃以右边最小的节点取代之）
30
20
10
15 5
25
50
40
60
45
6.6节练习题答案1.
2. 中序为ECBDA ，先序为ABCED ，其所对应的二叉树如下：
3. 中序为DFBAEGC ，后序为FDBGECA ，其所对应的二叉树如下：
A
B
F C
D
H G E I
J
N M
L
K A
B
D
C
E
B
C
E
D
F
G A
15 23 10 40 30 15 40 10 23 30 30
23
10
15 40
1
第七章 练习题答案
1.
♋ ♋
♋
2.
♋ ♋
40
30 10
23
15
1re 1
5
5
20
30 10 60
45
40
20 30
45
50
60
10
40
20
60
45
50
30
10
40
50 5
1re 2 1re 3
1re 4 1re 5 1re 6
1re 7
1re 8
1re 1
1re 2 1re 3
1re 4 1re 5
A-21
3. 删除节点30，则由节点5代替，由于删除后仍然符合Heap 的定义，因此不
需要调整。

删除30
♋
♋
♋
删除节点60，以节点10取代，由于删除后不符合Heap 的定义，因此需要调整。

删除60
♋
50与10交换 10与20交换
60 50 45 20
5
10 40
10
50
45 20 5
40
60 20 45 50
30 10
40
60
50
45 20
30
10
40
5
5
60
50 45 20 30
10
40
5
60
50 45 20
5
10
40
A-22
8 1 20
30 10
60 45
40
20
30 10 5 60
45
40
20
5 10 30 60
45
40
50 3 2 4 5 6 7 5
50
50
♋
♋
5
20 30
60
45
40
50
10
♋
♋
♋ OK!
4.
♋
(a) 加入17
调整
50 10
45 20
5 40
调整
50
20 45 10 5
40
这是一棵min-heap
A-23
20 30 10
8
12
18
15
14 17 16 6
2
20 30 10
8
2
18
15
14 17 16 6
12
20 30 10
8
6
18
15
14 17 16 2
12
12
30
10
8
6
18
2
17
30
10
8
6
18 2
加入8
16和18交换
ok!
加入2
12和2交换 6和2交换
(b) 删除20
12和17交换
20 30 10 16
12
18
15
14 17
6 20 30
10 16
12 18
15
14 17 6
8
20 30
10
8
12 18
15
14 17
6
16
A-24
17
30
16 8
6
18
15
14 12
2
17 30 14
8
15
16 12
2
6
18
再删除10
♋ OK!
7.3节练习题答案(a) 加入2
♋ ♋
再加入50
♋ ♋
5
30
10 14 26
22
16 20 18 2
5
30
10 2 26 22
16
20 18
14
2
30 10 5
26 22
16
20 18
14
2 30 5 26 22 16 20 18 14
10
50
2
30 5 50 22 16 20 18 14
10 26 2 50 5
30
22
16 20 18 14
10
26
A-25
(b) 删除50
2
26 5
30
22
16 20 18 14
10
2
30 5
26
22
16 20 18 14
10
第八章练习题答案
1.
(1) 加入Jan
(2) 加入Feb
(3) 加入Mar
(4) 加入Apr
(5) 加入May
Jan
Feb
Jan
Feb
Jan
Mar Feb
Jan
Mar Apr
A-26
A-27
(6) 加入Jun
(7) 加入July
(8) 加入Aug
Feb
Jan
Mar
Apr
May
Feb
Jan
Mar
Apr
May
Jun
Feb
Jan
Mar
Apr
May
Jun
July
Feb
Jan
Mar
Apr
May
Jun
July
Aug
A-28
属于LR 型，并调整。

(9) 加入Sep
(10) 加入Oct
Aug
Jan
Mar
Apr May
Jun
July
Feb Aug
Jan
Mar
Apr May
Jun
July
Feb Sep
Aug
Jan
Mar
Apr May
Jun
July
Aug Sep
Oct
A-29
属于RL 型，并调整。

(11) 加入Nov
属于RR 型，并调整
Aug
Jan
Mar
Apr Oct
Jun
July
Feb
Sep
May Aug
Jan
Mar
Apr
Oct
Jun
July
Feb
Sep
May
Nov
A-30
(12) 加入Dec
2.
(a) 删除30后，根据课文8.1节的解释，知其为RL 型
(b) 删除45后的AVL-tree 为
55 50
60
70
Jan
Mar
Oct
Aug
Sep
May
July
Jun Nov
Apr
Feb
Jan
Mar
Oct
Aug Sep
May
July
Jun Nov
Apr Feb Dec
A-31
由课文8.1节得知其为LR 型，调整后的AVL-tree
50
48
60 80
30
55
35 50
35 60 80
30 55
48
第九章练习题答案
1. 依次加入50、10、22及12
(1) 加入50
(2) 加入10
(3) 加入22
40,65
25 80
50
5, 15 35 45 55 75 85
40,65
10,25 80
50
5 35 45 55 75 85
15
15,22 40,65
10,25 80
50
5 35 45 55 75 85
A-32
A-33
(4) 加入12
2.
(1) 删除60
(2) 删除70
不符合2-3-tree ，再调整如下：
40
10 80
50
5
22
35 45
55
75 12 65
15 25
85
50 25 70 85
65
40
5
65, 85
40
5
25, 50 50 25 65, 85
40
5
A-34
75, 95
75, 95
35, 60
3. 删除70，由于删除后不符合2-3 Tree 之定义，故需调整。

60
35
95
15 50 75, 80 96
删除80，由于删除后符合2-3 Tree 之定义，故不需调整。

60
35
95
15 50 75 96
删除96，由于删除后不符合2-3 Tree 之定义，故需要调整。

60
35
=>
15 50
15 50
9.2节练习题答案1. 依序加入8，30及6 (1) 加入8
55
15
2, 5, 8
10, 40
(2) 加入30
(3)加入6
2.
(1) 删除80
(2) 删除30
(3) 删除8
15,30 55
2,5,8
10, 40
30 90
10, 60
5, 8
10 90
8, 60
5
90
60
5,10
15, 30 55
2
5, 10,
40
6, 8
A-35
A-36
(4) 删除90
60
10
5
A-37
第十章 练习题答案
(1) 加入30 (2) 加入50
(3) 加入25 (4) 加入32
(5) 加入35 (6) 加入33
(7) 加入28 (8) 加入29
(9) 加入60
30, x 30, 50
30, 50
25, x
30, 50 25, x
32, x
30, 50
25, 28 32, 35 33, x
29, x
30, 50
25, x 32, 35
30, 50
25, x
32, 25 33, x
30, 50 25, 28
32, 35
33, x
A-38
2. 接上题
(1) 删除28 (2) 删除35
(3) 删除50（此处是将50的左子树中最大的提上去）
30, 50
25, 29 32, 33 60, x
30, 50
25, 29 32, 35 33, x
60, x
30, 33
25, 29 32, x 60, x
30, 50
25, 28
32, 35
33, x
29, x
60, x
A-39
10.2节练习题答案1. (a) 加入33，加入后符合2-3-4 Tree 的定义，故不需调整
加入36，由于加入后不符合2-3-4 Tree 的定义，故需要调整。

加入38，由于加入后符合2-3-4 Tree 的定义，故不需调整。

50
10,30,40
60,80,100
8 20
33,35,37
55
65
105,110
45
85 50
10,30,35,4
60,80,100
8 33 36,37 55
65
105,110
45
85 20 50 10,30,35,40 60,80,100
8 33
36,37,38
55
65
105,110
45
85 20
A-40
50
10,30,35,4
60,80,10
8 33
36,37,38
55
65
45
85
20 110
50
10,30,35,4
60,80
8 33
36,37,38
55 65 45
20 85, 100
(b) 删除105，删除后符合2-3-4 Tree 的定义，故不需调整。

删除110，由于删除后不符合2-3-4 Tree 的定义，故需要调整。

第十一章 练习题答案
1.
2.
(a) 若V(G’) ⊆ V(G)及E(G’) ⊆ E(G)，则G’为G 的子图，如
(b)强连通单元为
1
1 4
11.2节练习题答案
邻接矩阵
A B C D E F G H
A 0 1 1 1 1 0 0 0
B 1 0 0 0 0 0 0 0
C 1 0 0 0 0 0 0 0
D 1 0 0 0 0 0 1 1
E 1 0 0 0 0 1 1 0
F 0 0 0 0 1 0 1 0
G 0 0 0 1 1 1 0 0
H 0 0 0 1 0 0 0 0 邻接表
A
B
C
D
E
F
G
H
11.3节练习题答案深度优先：AEFGDBC 广度优先：AEBCDFG 注意!上述答案不是惟一。

(a) Prime’s algorithm
→ → →
→
6 1 10 6 1
10 5
25 6 1 25
5 22
4 3 10 7
16 14 2
10
6
1 25 5 22
4
3 10 16
2 10
6 1
25 5
22
4
3
10 10
6 1
25
5
22
4
10
6 1 25 5 22 4 10 3 10
7 2 16 14 26
18 24 6 1 5 4 10 3 7 2 6 1 5 4 10 3 10 7 2 6 1
5 4 10 3 10 7 2
14 6 1 5
4
10 3 10
7 2
14 16
16 6 1 5 4
10 3 10
7 2 14 22
6 1 5 4
10 3
10
7 2 14 16 22
25 (b) Kruskal’s algorithm
→ → →
→ →
(c) Sollin’s algorithm
以每一个节点为起点，找一边为其最短 (1,6)，(2,7)，(3,4)，(4,3)，(5,4)，(6,1)，(7,2) 其中(1,6)，(6,1)，(3,4)和(4,3)及(2,7)和(7,2)都重复 因此，保留(1,6)，(2,7)，(3,4)，(5,4)
6
1 5 4
10 3
10
7
2 14 22
之后(1,6)，(2,7)，(3,4,5)所组成的tree 取之间最短的边分别为(2,3)及(5,6)
11.5节练习题答案
由上表得知节点1到节点7最短距离为2，并且经由5个路径，分别如下 <1, 4>, <4, 3>,<3, 2>,<2, 5>,<5, 7>。

其余节点的最短距离依此类推。

(a) 拓扑排序： ， ，●，❍，⏹，☐
注意!此答案不是惟一。

也可以是 ， ，●，❍，⏹，☐
6 1
5 4
10 3
10
7 2 14 16
22
25
(b)
count Link vertex Link
V1
V2
V3
V4
V5
V6
其中link字段为0或以斜线表示的话，代表以联机到此结束。

1.
表一：每一顶点ES值
表二：每一顶点的LS值
从表一和表二得知，若任何一顶点的ES等于LS时，LS(i)–LS(i)=ES(j)–ES(i)=a ij 则此路径为关键路径。

故<1,2>，<2,4>，<4,5>，<5,7>为关键路径。

第十二章 练习题答案
第一次扫描
15 8 20 7 66 54 8 15 20 7 66 54 8 15 20 7 66 54
8 15 7 20 66 54 8 15 7 20 66 54
结果
8 15 7 20 54 66
第二次扫描
8 15 7 20 54 8 15 7 20 54
8 7 15 20 54 8 7 15 20 54
结果
8 7 15 20 54
第三次扫描
8 7 15 20 7 8 15 20 7 8 15 20 结果
7
8
15
20
此时在比较的步骤中，并无调换的操作，故得知排序的工作已完成。

换
换
换
换
12.2节练习题答案
15 8 20 7 66 54 18 26 经由比较结果，得知最小的数为7，故将它和第一个元素对调
7 8 20 15 66 54 18 26
从第2个元素开始找最小的，得知为8，而它本身就在第2个位置
7 8 20 15 66 54 18 26
依此进行，最后的结果为
7 8 15 18 20 26 54 66
12.3节练习题答案
12.4节练习题答案
15 8 20 7 66 54 18 26
8 15 7 20 54 66 18 26
7 8 15 20 18 26 54 66
7 8 15 18 20 26 54 66
15 8 20 7 66 54 18 26
i
15 8 7 20 66 54 18 26
j i
[ 7 8 ] 15 [ 20 66 54 18 26 ] [ 7 8 ] 15 [ 20 66 54 18 26 ]
i j
[ 7 8 ] 15 [ 20 18 54 66 26 ]
j i
[ 7 8 ] 15 [ 18 ] 20 [ 54 66 26 ] [ 7 8 ] 15 18 20 [ 54 66 26 ]
…
[ 7 8 ] 15 18 20 26 54 66。