数据结构第9章-1

设n=10000,
= (b+1)/2 + (s+1)/2
1.顺序查找的ASL=5000
= (b+s)/2 +1
=
1 2
(
n s
+
s)
+
1
2.折半查找的ASL=14 3.分块查找的ASL=101
当s取 n 时， ASLbs= n +1 为最小值。
如果n=400, 则b=20, s=20时，查找性能最佳。 21
st.elem[0].key= k； // 监视哨 i= st.length；
while (st.elem[i].key≠k) i--；
return(i)
} //seqsrch
查找方法评价
算法本身复杂程度
占用存储空间多少
查找速度 —— 平均查找长度ASL
( Average Search Length ) 为确定记录在查找表中的位置，需要和给定值
i=st.length； while (st.elem[i].key≠k && i>0) i-- ；
return(i)
} // seqsrch
改进：
在st.elem[0]处设立监视哨，可以减少查找时间i
i
64 21 37 88 19 92 05 64 56 80 75 13
0 1 2 3 4 5 6 7 8 9 10 11
时按实际长度分配，0号单元不存记录。
int length； // 静态查找表的长度
} SqList ；
9.1.1 顺序查找
如果数组中关键字的排列是无序的，只能 进行逐个查找。可采用顺查或逆查。 int seqsrch(SqList st， KeyType k){
//在静态表st中，查找key域为k的记录的位置，若不存在返回0
可使用折半（二分）查找来实现。
折半查找算法：
假设有一序列存在数组 r 中，指针low和high分 别指示查找范围的下界和上界，mid指示区间 的中间位置，即
mid = (low + high) / 2 首先令r[mid].key与给定值k相比较， 如果 (1) r[mid].key = k，则查找成功。（退出） (2) k < r[mid].key，
则在[low, mid-1]范围内查找。 (3) k > r[mid].key，
则在[mid+1, high]范围内查找
例如: key = 64 的查找过程如下
05 13 19 21 37 56 64 75 80 88 92
0 1 2 3 4 5 6 7 8 9 10 11
low
low high
high
kval = 64
i
i
60 21 37 88 19 92 05 64 56 80 75 13
0 1 2 3 4 5 6 7 8 9 10 11
kval = 60
改进： 在st.elem[0]处设立监视哨。
st.elem
k
……
012 3 4 …
st.length
int seqsrch(SqList st，KeyType k){
}
(2) 生成二叉排序树的算法：
BiTree crt_bstree(BiTree &root){
//输入一个关键字序列，生成一棵二叉排序树的二叉链表结构
所以：若树中结点的个数为n，则：
查找成功的比较次数至多为 log2n + 1。 查找不成功时的比较次数也不超过 log2n +1。
假设 n=2h-1 并且查找概率相等
则
ASLbs

1 n
n i1
Ci

1 n

h j1
j

2
j-1



n
+ n
1
log
2
(n
+1) -1
表中不存在的数据元素，或者从查找表中 删除已存在的某个数据元素。
3
本章以后各节中涉及的数据元素类型统一定义为：
typedef struct {
KeyType key；
……
；
} ElemType
//关键字成员 //其它成员
静态查找表的类型描述：
typedef struct{ ElemType * elem；//数据元素存储空间的首地址，建表
关键字项 — 每个子表元素的最大值 指针项 -- 子表中第一个元素在线性表中的位置1。9
特点： 1.整个表按块有序，但表内可以无序。 2.索引表每个记录对应一块，并按关键字有序。
关键字项 22 48 86 指针项 1 7 13 索引表
22 5 13 8 9 20 33 42 44 38 24 48 60 58 74 47 86 53
else low = mid+1； }； if (low ≤high) return(mid)；
else return(0)
} // binsrch
折半查找递归算法：
分析: 1) 限制条件: 下界low，上界high。函数头如下:
int binsrch(SqList st, KeyType k, int low, int high)
mid mid mid
low ： 指示查找区间的下界 high ： 指示查找区间的上界 mid = (low+high) / 2
例如: key =206 64 75 80 88 92
0 1 2 3 4 5 6 7 8 9 10 11
low
mid
high
查找过程分两步进行： (1) 确定待查记录所在的块。 (2) 在相应的块内查找
n — 表长 (18) s — 块长 (6) b — 块数 (3)
ASLbs = Lb + LS
索引表的平均查找长度 静块态内的查平找均表查找中长3度种方法 若都采用顺序查找，则 的平均查找长度比较:
ASLbs = Lb + Ls
mid
high
midlow
high
折半查找非递归算法：
int binsrch(SqList st， KeyType k){
//在静态表st中折半查找的非递归算法，若不存在返回0
low = 1 ； high = st.length；
while(low ≤high){ mid = (low + high)/ 2； if (st.elem[mid].key == k) break； else if(st.elem[mid].key>k) high=mid-1；
}
} //bisrch
分析折半查找的平均查找长度
先看一个具体的情况，假设：n=11
i 1 2 3 4 5 6 7 8 9 10 11 Ci 3 4 2 3 4 1 3 4 2 3 4
判定树
3
6 9
1
4
7
10
2
5
8
11
ASLSUCC =(1*1+2*2+3*4+4*4)/11 = 33/11 =3
判定树是理想平衡二叉树
return（bstsrch(bt→rchild，k)） else
return（bstsrch(bt→lchild，k)）； }
3. 二叉排序树的构造
特点：树结构在查找的过程中动态生成。 每次插入的结点只能成为新的叶子结点
例：关键字序列为 {45，24，53，12，12，90 }
45 24
12 12
n
PiCi
i 1

n1
i1 n
(n -i+1)

1
n
(n
- i +1)
n+1
n i1
2
查找不成功时： ASLunsucc = n + 1
9.1.2 有序表的查找
有序表：表中的记录按关键字有序排列。
即： st.elem[i].key≤ st.elem[i+1].key； (i=1，2，……，n-1)
2) 基本公式：当low>high时 , 返回值为0; 3) 一般公式 ：
mid = (low + high) / 2; 如果： ① r[mid].key = k，返回值mid的值（退出） ② k < r[mid].key，则返回在[low, mid-1]范围内查 找的结果。
即: return(binsrch(st, k, low, mid-1)；
switch { case st.elem[[mid].key == k：return(mid)； case st.elem[mid].key > k：
return(binsrch(st, k, low, mid-1)； case st.elem[mid].key < k：
return(binsrch(st, k, mid+1, high)；
9.1 静态查找表 9.2 动态查找树表 9.3 哈希表
查找：在不同的表结构中查找指定元素。
查找到指定元素— 返回该元素在表中的位 置。 若找不到满足条件的元素— 查找失败，返 回特定值。
元素(记录)的关键字：可以标识一个元素(记
录)的数据项值
不同的表结构(查找表)采用不同的查找方法
查找表： 同一类型的数据元素的存储结构 基本操作：查找，插入，删除。 静态查找表：对表只作查找操作。 动态查找表：在查找过程中同时插入查找
53 90
(1) 插入算法： status ins_bstree(BiTree &bt，BiTree s){